Annotation of OpenXM/src/kan96xx/plugin/oxmisc2.c, Revision 1.22
1.22 ! takayama 1: /* $OpenXM: OpenXM/src/kan96xx/plugin/oxmisc2.c,v 1.21 2004/03/01 07:19:45 takayama Exp $ */
1.1 maekawa 2: #include <stdio.h>
3: #include "ox_kan.h"
4: #include "oxmisc2.h" /* This file requires sm1 object description. */
5: #include "cmo.h"
1.8 takayama 6:
1.1 maekawa 7: extern FILE *MyErrorOut;
1.6 takayama 8: #define SET_MYERROROUT { if (MyErrorOut == NULL) MyErrorOut=stdout; }
9: /* It is also defined in oxmisc.c */
10:
1.1 maekawa 11: extern int SerialOX; /* defined in SerialOX */
12:
13: extern int OxVersion;
14:
15: int DebugMathCap = 1;
16:
17:
18:
19: int oxGet(oxclientp client, struct object *op,int *isObj)
1.12 takayama 20: /* This method should be synchronized. */
21: /* oxGet is a function for client. */
1.1 maekawa 22: {
23: int ans;
24: ox_stream os;
25: int m;
26: struct object rob;
27: int sss; /* Serial number of the recieved packet. */
28: *isObj = 0;
29: op->tag = Snull;
30: os = client->datafp2;
31: switch(client->dstate) {
32: case DSTATE_ANY:
33: m = oxGetOXheader(os,&sss);
34: switch(m) {
35: case OX_DATA:
36: client->dstate = DSTATE_WAIT_OX_DATA;
37: return(oxGet(client,op,isObj));
38: case OX_SYNC_BALL:
39: client->dstate = DSTATE_ANY;
40: return(OX_SYNC_BALL);
41: default:
42: errorOxmisc2("oxGet: cannot handle this tag.\n");
43: client->dstate = DSTATE_ERROR;
44: return(-1);
45: }
46: break;
47: case DSTATE_FIRST_SYNC: /* waiting the first sync ball */
48: /* I need to clear the buffer?? */
49: oxWaitSyncBall(os);
50: client->dstate = DSTATE_ANY;
51: oxSendSyncBall(os);
52: return(OX_SYNC_BALL);
53: break;
54: case DSTATE_WAIT_OX_DATA: /* waiting a cmo data. */
55: *op = cmoObjectFromStream2(client->datafp2);
56: client->dstate = DSTATE_ANY;
57: *isObj = 1;
58: return(0);
59: break;
60: case DSTATE_ERROR:
61: client->dstate = DSTATE_ERROR;
62: errorOxmisc2("oxGet: dstate == DSTATE_ERROR (error state)\n");
63: return(-1);
64: default:
65: client->dstate = DSTATE_ERROR;
66: errorOxmisc2("oxGet: Unknown state number.");
67: }
68:
69: return(-1);
70: }
71:
72: int oxGetFromControl(oxclientp client)
73: {
74: int ans = -1;
1.7 takayama 75: AbortIfRFC_101(client);
1.1 maekawa 76: if (client->cstate != -1) {
77: ans = oxGetResultOfControlInt32(client->controlfd);
78: if (ans != -1) { client->cstate = 0; }
79: else {client->cstate = -1; }
80: }
81: return(ans);
82: }
83:
84: int oxReq(oxclientp client,int func,struct object ob)
85: {
86: struct object *ob1p;
1.6 takayama 87: SET_MYERROROUT;
1.1 maekawa 88: /* request to the control channel */
89: if (func == SM_control_reset_connection ||
90: func == SM_control_kill) {
1.12 takayama 91: AbortIfRFC_101(client);
1.1 maekawa 92: switch(func) {
93: case SM_control_reset_connection:
94: oxReqControlResetConnection(client->controlfd);
1.9 takayama 95: client->cstate = 0;
1.1 maekawa 96: client->dstate = DSTATE_FIRST_SYNC;
97: break;
98: case SM_control_kill:
99: oxReqControlKill(client->controlfd);
100: client->cstate = 0;
101: client->dstate = DSTATE_ANY;
102: break;
103: }
104: fflush(NULL);
105: return(0);
106: }
107:
108: /* request to the data channel */
109: if (client->dstate != DSTATE_ANY) {
110: errorOxmisc2("oxReq: client->dstate != DSTATE_ANY, data channel is not ready to send data.\n");
111: return(-1);
112: }
113: switch(func) {
114: case SM_DUMMY_sendcmo:
115: if (!cmoCheckMathCap(ob,(struct object *)client->mathcapObjp)) {
116: errorOxmisc2("oxReq: your peer does not understand this cmo.\n");
117: return(-1);
118: }
119: oxSendOXheader(client->datafp2,OX_DATA,SerialOX++);
120: cmoObjectToStream2(ob,client->datafp2);
121: client->dstate = DSTATE_ANY;
122: break;
123: case SM_sync_ball:
124: oxSendSyncBall(client->datafp2);
125: client->dstate = DSTATE_ANY; /* We do not expect the sync ball.*/
126: client->cstate = 0; /* clear the cstate */
127: break;
128: case SM_popCMO:
129: oxReqPopCMO(client->datafp2);
130: client->dstate = DSTATE_ANY;
131: break;
132: case SM_mathcap:
133: oxReqMathCap(client->datafp2);
134: client->dstate = DSTATE_ANY;
135: break;
136: case SM_setMathCap:
137: /* ob = [(mathcap-obj) [[version num, system name] [sm tags]
1.12 takayama 138: ob1 smtags
139: oxtags [[ox numbers, [cmo numbers]]]
140: ob3 ob2 */
141: /* oxtags [[OX_DATA, [cmo numbers]],[OX_DATA_LOCAL,[opt]],...]*/
1.1 maekawa 142: {
143: struct object ob1;
144: struct object ob2;
145: struct object ob3;
1.4 takayama 146: struct object obm;
1.1 maekawa 147: struct object smtags;
1.4 takayama 148: struct object oxtags;
149: struct object ox;
1.12 takayama 150: int n,i;
151: struct mathCap mathcap;
1.1 maekawa 152:
1.12 takayama 153: if (strcmp(KopString(getoa(ob,0)),"mathcap-object") != 0) {
154: errorOxmisc2("data format error in oxReqSetMathCap");
155: client->dstate = DSTATE_ANY;
156: break;
157: }
1.4 takayama 158: obm = getoa(ob,1);
159: ob1 = getoa(obm,0);
160: smtags = getoa(obm,1);
161: oxtags = getoa(obm,2);
162: if (smtags.tag != Sarray || oxtags.tag != Sarray) {
1.12 takayama 163: errorOxmisc2("data format error in oxReqSetMathCap");
1.4 takayama 164: }
1.1 maekawa 165: ob1p = (struct object *) sGC_malloc(sizeof(struct object));
166: *ob1p = ob1;
167: mathcap.infop = ob1p;
1.4 takayama 168:
169: n = getoaSize(oxtags);
1.1 maekawa 170: if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
171: mathcap.oxSize = n;
172: for (i=0; i<n; i++) {
1.12 takayama 173: ox = getoa(oxtags,i);
174: if (ox.tag != Sarray) {
175: errorOxmisc2("Data format error of the third argument of mathcap.");
176: }
177: mathcap.ox[i] = KopInteger(getoa(ox,0));
178: if (mathcap.ox[i] == OX_DATA) {
179: if (getoaSize(ox) < 2) {
180: errorOxmisc2("Data format error in an entry of the third argument of mathcap.");
181: }
182: ob2 = getoa(ox,1);
183: if (ob2.tag != Sarray) {
184: errorOxmisc2("Data format error in an entry of the third argument of mathcap.");
185: }
186: mathcap.n = getoaSize(ob2);
187: if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
188: for (i=0; i<mathcap.n; i++) {
189: mathcap.cmo[i] = KopInteger(getoa(ob2,i));
190: }
191: }
1.1 maekawa 192: }
193:
194: n = getoaSize(smtags);
195: if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
196: mathcap.smSize = n;
197: for (i=0; i<n; i++) {
1.12 takayama 198: mathcap.sm[i] = KopInteger(getoa(smtags,i));
1.1 maekawa 199: }
200:
201: oxReqSetMathCap(client->datafp2,&mathcap);
202: client->dstate = DSTATE_ANY;
203: }
204: break;
205: case SM_pops:
206: if (ob.tag != Sinteger) {
207: errorOxmisc2("SM_pops : the argument must be an integer.");
208: return(-1);
209: }
210: oxReqPops(client->datafp2, KopInteger(ob));
211: client->dstate = DSTATE_ANY;
212: break;
213: case SM_executeStringByLocalParser:
214: if (ob.tag != Sdollar) {
215: errorOxmisc2("SM_executeStringByLocalParser : the argument must be a string.");
216: return(-1);
217: }
218: oxReqExecuteStringByLocalParser(client->datafp2,KopString(ob));
219: client->dstate = DSTATE_ANY;
220: break;
221: case SM_executeFunction:
222: if (ob.tag != Sdollar) {
223: errorOxmisc2("SM_executeFunction : the argument must be a string.");
224: return(-1);
225: }
226: oxReqExecuteFunction(client->datafp2,KopString(ob));
1.22 ! takayama 227: client->dstate = DSTATE_ANY;
! 228: break;
! 229: case SM_executeFunctionWithOptionalArgument:
! 230: if (ob.tag != Sdollar) {
! 231: errorOxmisc2("SM_executeFunctionWithOptionalArgument : the argument must be a string.");
! 232: return(-1);
! 233: }
! 234: oxReqExecuteFunctionWithOptionalArgument(client->datafp2,KopString(ob));
1.1 maekawa 235: client->dstate = DSTATE_ANY;
236: break;
237: case SM_popString:
238: oxReqPopString(client->datafp2);
239: client->dstate = DSTATE_ANY;
240: break;
241: case SM_evalName:
242: if (ob.tag != Sdollar) {
243: errorOxmisc2("SM_evalName : the argument must be a string.");
244: return(-1);
245: }
246: oxReqEvalName(client->datafp2,KopString(ob));
247: client->dstate = DSTATE_ANY;
248: break;
249: case SM_setName:
250: if (ob.tag != Sdollar) {
251: errorOxmisc2("SM_setName : the argument must be a string.");
252: return(-1);
253: }
254: oxReqSetName(client->datafp2,KopString(ob));
255: client->dstate = DSTATE_ANY;
256: break;
257: case SM_getsp:
258: oxReqSingleOperand(client->datafp2,SM_getsp);
259: client->dstate = DSTATE_ANY;
260: break;
261: case SM_dupErrors:
262: oxReqSingleOperand(client->datafp2,SM_dupErrors);
1.21 takayama 263: client->dstate = DSTATE_ANY;
264: break;
265: case SM_pushCMOtag:
266: oxReqSingleOperand(client->datafp2,SM_pushCMOtag);
1.1 maekawa 267: client->dstate = DSTATE_ANY;
268: break;
269: default:
270: fprintf(MyErrorOut,"func=%d ",func);
271: errorOxmisc2("This function is not implemented.");
272: break;
273: }
274: fp2fflush(client->datafp2);
275: return(0);
276: }
277:
278: struct object KoxCreateClient(struct object ip,
1.12 takayama 279: struct object portStream,
280: struct object portControl)
1.1 maekawa 281: {
282: struct object rob;
283: oxclientp client;
284: rob.tag = Snull;
285: if (ip.tag != Sdollar) {
286: errorOxmisc2("KoxCreateClient(): The first argument must be a hostname given by a string.");
287: return(rob);
288: }
289: if (portStream.tag == Sdollar) {
290: client = oxCreateClientFile(KopString(ip),KopString(portStream),
1.12 takayama 291: "/dev/null","w");
1.1 maekawa 292: if (client == NULL) {
293: errorOxmisc2("KoxCreateClient(): Open error.");
294: return(rob);
295: }
296: rob = newObjectArray(N_OF_CLIENT_FIELDS);
297: oxClientToObject(client,rob);
298: return(rob);
299: }
300:
301: if (portStream.tag != Sinteger) {
302: errorOxmisc2("KoxCreateClient(): The second argument must be a port number given in an integer.");
303: return(rob);
304: }
305: if (portControl.tag != Sinteger) {
306: errorOxmisc2("KoxCreateClient(): The third argument must be a port number given in an integer.");
307: return(rob);
308: }
309: client = oxCreateClient(KopString(ip),KopInteger(portStream),KopInteger(portControl));
310: if (client == NULL) {
311: errorOxmisc2("KoxCreateClient(): Open error.");
312: return(rob);
313: }
314: rob = newObjectArray(N_OF_CLIENT_FIELDS);
315: oxClientToObject(client,rob);
1.14 takayama 316: oxClientListUpdate(rob);
1.1 maekawa 317: return(rob);
318: }
319:
320: static int isItClientObject(struct object ob)
321: {
322: int size,i;
323: struct object ee[N_OF_CLIENT_FIELDS];
324: if (ob.tag != Sarray) {
325: return(0);
326: }
327: size = getoaSize(ob);
328: if (size != N_OF_CLIENT_FIELDS) return(0);
329: for (i=0; i<N_OF_CLIENT_FIELDS; i++) {
330: ee[i] = getoa(ob,i);
331: }
332:
333: if (ee[0].tag != Sdollar) return(0);
334: if (strcmp(KopString(ee[0]),"client")!=0) return(0);
335:
336: if (ee[1].tag != Sfile) return(0);
337: if (strcmp((ee[1]).lc.str,MAGIC2) != 0) return(0);
338:
339: for (i=2; i<=9; i++) {
340: if (ee[i].tag != Sinteger) return(0);
341: }
342: return(1);
343: }
344:
345:
346: struct object KoxIsThereErrorClient(struct object ob)
347: {
348: struct object rob;
349: int ans;
350: int size;
351: oxclient cc;
352: rob.tag = Snull;
353: if (!isItClientObject(ob)) {
354: errorOxmisc2("KoxIsThereErrorClient(): the argument must be an array for client object.");
355: return(rob);
356: }
357: if (oxObjectToClient(ob,&cc) == -1) return(KpoInteger(-1));
358: ans = oxIsThereErrorClient(&cc);
359: return(KpoInteger(ans));
360: }
361:
362: int oxClientToObject(oxclientp client,struct object rob)
363: {
364: struct object ob;
365: if (client == NULL) return;
366: /* rob = newObjectArray(N_OF_CLIENT_FIELDS); */
367: if (rob.tag != Sarray) {
368: errorOxmisc2("oxClientToObject(): the second argument must be an array.");
369: return(-1);
370: }
371: if (getoaSize(rob) != N_OF_CLIENT_FIELDS) {
372: errorOxmisc2("oxClientToObject(): the second argument must be an array of size N_OF_CLIENT_FIELDS.");
373: return(-1);
374: }
375:
376: ob = KpoString("client");
377: putoa(rob,0,ob);
378:
379: ob.tag = Sfile; ob.lc.str = MAGIC2; ob.rc.voidp = (void *)(client->datafp2);
380: putoa(rob,1,ob);
381:
382: putoa(rob,2,KpoInteger(client->dataport));
383: putoa(rob,3,KpoInteger(client->controlfd));
384: putoa(rob,4,KpoInteger(client->controlport));
385: putoa(rob,5,KpoInteger(client->dstate));
386: putoa(rob,6,KpoInteger(client->cstate));
387: putoa(rob,7,KpoInteger(client->humanio));
388: putoa(rob,8,KpoInteger(client->id));
389: putoa(rob,9,KpoInteger(client->type));
390: if (client->mathcapObjp == NULL) {
391: putoa(rob,10,NullObject);
392: }else{
393: putoa(rob,10,*((struct object *)(client->mathcapObjp)));
394: }
395: putoa(rob,11,KpoInteger(client->engineByteOrder));
396: putoa(rob,12,KpoInteger(client->controlByteOrder));
1.16 takayama 397: putoa(rob,13,KpoInteger(client->engineID));
1.1 maekawa 398: return(0);
399: }
400:
401: int oxObjectToClient(struct object ob,oxclientp cp)
402: {
403: struct object ob1;
404: struct object *obp;
405: if (cp == NULL) {
406: errorOxmisc2("oxObjectToClient(): the second argument is NULL");
407: return(-1);
408: }
409: if (!isItClientObject(ob)) {
410: errorOxmisc2("oxObjectToClient(): the first argument is not client object.");
411: oxInitClient(cp);
412: return(-1);
413: }
414:
415: ob1 = getoa(ob,1);
416: cp->datafp2 = (FILE2 *) (ob1.rc.voidp);
417:
418: ob1 = getoa(ob,2);
419: cp->dataport = KopInteger(ob1);
420:
421: ob1 = getoa(ob,3);
422: cp->controlfd = KopInteger(ob1);
423:
424: ob1 = getoa(ob,4);
425: cp->controlport = KopInteger(ob1);
426:
427: ob1 = getoa(ob,5);
428: cp->dstate = KopInteger(ob1);
429:
430: ob1 = getoa(ob,6);
431: cp->cstate = KopInteger(ob1);
432:
433: ob1 = getoa(ob,7);
434: cp->humanio = KopInteger(ob1);
435:
436: ob1 = getoa(ob,8);
437: cp->id = KopInteger(ob1);
438:
439: ob1 = getoa(ob,9);
440: cp->type = KopInteger(ob1);
441:
442: ob1 = getoa(ob,10);
443: if (ob1.tag == Snull) {
444: cp->mathcapObjp = NULL;
445: }else{
446: obp = (struct object *) sGC_malloc(sizeof(struct object));
447: *obp = ob1;
448: cp->mathcapObjp = (void *)obp;
449: }
450: ob1 = getoa(ob,11);
451: cp->engineByteOrder = KopInteger(ob1);
452: ob1 = getoa(ob,12);
453: cp->controlByteOrder = KopInteger(ob1);
1.16 takayama 454:
455: ob1 = getoa(ob,13);
456: cp->engineID = KopInteger(ob1);
1.1 maekawa 457:
458:
459: return(0);
460: }
461:
462: struct object KoxReq(struct object client,
1.12 takayama 463: struct object func,
464: struct object ob1)
1.1 maekawa 465: {
466: int ans;
467: static oxclientp cc1 = NULL;
468: struct object rob;
469: rob.tag = Snull;
470: if (cc1 == NULL) {
471: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
472: if (cc1 == NULL) {
473: errorOxmisc2("KoxReq(): no more memory.");
474: return(rob);
475: }
476: oxInitClient(cc1);
477: }
478:
479: if (oxObjectToClient(client,cc1) == -1) return(rob);
480: if (cc1 == NULL) {
481: errorOxmisc2("KoxReq(): the first argument must be a client object.");
482: return(rob);
483: }
484: if (func.tag != Sinteger) {
485: errorOxmisc2("KoxReq(): the second argument must be an integer.");
486: return(rob);
487: }
488: ans = oxReq(cc1,KopInteger(func),ob1);
489: /* synchronize cc1 and client. */
490: oxClientToObject(cc1,client);
491:
492: return(KpoInteger(ans));
493: }
494:
495: struct object KoxGet(struct object client)
496: {
497: int ans,k;
498: static oxclientp cc1 = NULL;
499: struct object rob;
500: rob.tag = Snull;
501: if (cc1 == NULL) {
502: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
503: if (cc1 == NULL) {
504: errorOxmisc2("KoxGet(): no more memory.");
505: return(rob);
506: }
507: oxInitClient(cc1);
508: }
509:
510: if (oxObjectToClient(client,cc1) == -1) return(rob);
511: if (cc1 == NULL) {
512: errorOxmisc2("KoxGet(): the first argument must be a client object.");
513: return(rob);
514: }
515:
516: ans = oxGet(cc1,&rob,&k);
517: /* synchronize cc1 and client. */
518: oxClientToObject(cc1,client);
519:
520: if (k) return(rob);
521: else {
522: return(KpoInteger(ans));
523: }
524: }
525:
526: struct object KoxGetFromControl(struct object client)
527: {
528: int ans;
529: static oxclientp cc1 = NULL;
530: struct object rob;
531: rob.tag = Snull;
532: if (cc1 == NULL) {
533: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
534: if (cc1 == NULL) {
535: errorOxmisc2("KoxGetFromControl(): no more memory.");
536: return(rob);
537: }
538: oxInitClient(cc1);
539: }
540:
541: if (oxObjectToClient(client,cc1) == -1) return(rob);
542: if (cc1 == NULL) {
543: errorOxmisc2("KoxGetFromControl(): the first argument must be a client object.");
544: return(rob);
545: }
546:
547: ans = oxGetFromControl(cc1);
548: /* synchronize cc1 and client. */
549: oxClientToObject(cc1,client);
550:
551: return(KpoInteger(ans));
552: }
553:
554: struct object KoxMultiSelect(struct object oclients,struct object t)
555: {
556: static int first = 1;
557: static int csize = 0;
558: static oxclientp *clients = NULL;
559: oxclientp cc1;
560: struct object rob;
561: int i;
562: int tt;
563: struct object ob1;
564: struct object ob2;
565: struct object ob0;
566: int size;
567: int ans;
568: int dataready[1024];
569: int controlready[1024];
570:
571: rob.tag = Snull;
572: if (oclients.tag != Sarray) {
573: errorOxmisc2("KoxMultiSelect(): the first argument must be an array.");
574: return(rob);
575: }
576: size = getoaSize(oclients);
577: if (first) {
578: first = 0; csize = size;
579: clients = (oxclientp *)mymalloc(sizeof(oxclientp)*(size+1));
1.12 takayama 580: if (clients == NULL) {
1.1 maekawa 581: errorOxmisc2("KoxMultiSelect(): no more memory.");
582: return(rob);
583: }
584: for (i=0; i<size; i++) {
585: clients[i] = (oxclientp) mymalloc(sizeof(oxclient));
586: if (clients[i] == NULL) {
1.12 takayama 587: errorOxmisc2("KoxMultiSelect(): no more memory.");
588: return(rob);
1.1 maekawa 589: }
590: oxInitClient(clients[i]);
591: }
592: }
593: if (csize < size) {
594: first = 1;
595: return(KoxMultiSelect(oclients,t));
596: }
597: for (i=0; i<size; i++) {
598: ob0 = getoa(oclients,i);
599: if (oxObjectToClient(ob0,clients[i]) == -1) return(rob);
600: }
601: if (t.tag != Sinteger) {
602: errorOxmisc2("KoxMultiSelect(): the second argument must be an integer.");
603: }
604: tt = KopInteger(t);
605: ans = oxclientMultiSelect(clients,dataready,controlready,size,tt);
606: /* synchronize oclients and clients. */
607: for (i=0; i<size; i++) {
608: ob0 = getoa(oclients,i);
609: oxClientToObject(clients[i],ob0);
610: putoa(oclients,i,ob0);
611: }
612: rob = newObjectArray(3);
613: putoa(rob,0,KpoInteger(ans));
614: ob1 = newObjectArray(size);
615: ob2 = newObjectArray(size);
616: for (i=0; i<size; i++) {
617: putoa(ob1,i,KpoInteger(dataready[i]));
618: putoa(ob2,i,KpoInteger(controlready[i]));
619: }
620: putoa(rob,1,ob1);
621: putoa(rob,2,ob2);
622: return(rob);
623: }
624:
625: struct object KoxWatch(struct object client,struct object f)
1.12 takayama 626: /* f is not used for now. It should be log file. */
1.1 maekawa 627: {
628: int ans,k;
629: static oxclientp cc1 = NULL;
630: struct object rob;
1.3 takayama 631: extern int WatchStream;
1.1 maekawa 632: rob.tag = Snull;
1.3 takayama 633: if (client.tag == Sinteger) {
1.12 takayama 634: if (KopInteger(client)) {
635: WatchStream = 1;
636: }else{
637: WatchStream = 0;
638: }
639: return;
1.3 takayama 640: }
1.1 maekawa 641: if (cc1 == NULL) {
642: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
643: if (cc1 == NULL) {
644: errorOxmisc2("KoxWatch(): no more memory.");
645: return(rob);
646: }
647: oxInitClient(cc1);
648: }
649:
650: if (oxObjectToClient(client,cc1) == -1) return(rob);
651: if (cc1 == NULL) {
652: errorOxmisc2("KoxWatch(): the first argument must be a client object.");
653: return(rob);
654: }
655:
656: k = fp2watch(cc1->datafp2,stdout);
657: /* synchronize cc1 and client. */
658: oxClientToObject(cc1,client);
659:
660: return(KpoInteger(ans));
661: }
662:
1.18 takayama 663: struct object KoxLog(struct object client,struct object in,struct object out)
664: {
665: int ans,k;
666: static oxclientp cc1 = NULL;
667: struct object rob;
668: rob.tag = Snull;
669: if (cc1 == NULL) {
670: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
671: if (cc1 == NULL) {
672: errorOxmisc2("KoxLog(): no more memory.");
673: return(rob);
674: }
675: oxInitClient(cc1);
676: }
677:
678: if (oxObjectToClient(client,cc1) == -1) return(rob);
679: if (cc1 == NULL) {
680: errorOxmisc2("KoxLog(): the first argument must be a client object.");
681: return(rob);
682: }
683:
684: if (in.tag != Sfile) {
685: errorOxmisc2("KoxLog(): the second argument is not a file object.");
686: return rob;
687: }
688: if (out.tag != Sfile) {
689: errorOxmisc2("KoxLog(): the third argument is not a file object.");
690: return rob;
691: }
692: k = fp2log(cc1->datafp2,in.rc.file,out.rc.file);
1.19 takayama 693: fputc(cc1->engineByteOrder,out.rc.file); /* Output engineByteOrder. */
1.18 takayama 694: /* synchronize cc1 and client. */
695: oxClientToObject(cc1,client);
696:
697: return(KpoInteger(ans));
698: }
699:
700: struct object KoxLogStop(struct object client) {
701: static oxclientp cc1 = NULL;
702: struct object rob;
703: rob.tag = Snull;
704: if (cc1 == NULL) {
705: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
706: if (cc1 == NULL) {
707: errorOxmisc2("KoxLog(): no more memory.");
708: return(rob);
709: }
710: oxInitClient(cc1);
711: }
712:
713: if (oxObjectToClient(client,cc1) == -1) return(rob);
714: if (cc1 == NULL) {
715: errorOxmisc2("KoxLog(): the first argument must be a client object.");
716: return(rob);
717: }
718: return(KpoInteger(fp2stopLog(cc1->datafp2)));
719: }
1.1 maekawa 720:
721: struct object KoxCloseClient(struct object client) {
722: oxclientp cc1 = NULL;
723: oxclient cc;
724: struct object rob;
725: rob.tag = Snull;
726: cc1 = &cc;
727: if (oxObjectToClient(client,cc1) == -1) return(rob);
728: if (cc1 == NULL) {
729: errorOxmisc2("KoxCloseClient(): the first argument must be a client object.");
730: return(rob);
731: }
732:
733: fp2fflush(cc1->datafp2);
734: if (cc1->humanio) {
735: /* Do not close the file. */
736: return(KpoInteger(0));
737: }
738: switch (cc1->type) {
739: case CLIENT_SOCKET:
740: fp2fclose(cc1->datafp2);
741: close(cc1->controlfd);
742: break;
743: case CLIENT_FILE:
744: fp2fclose(cc1->datafp2);
745: close(cc1->controlfd);
746: break;
747: default:
748: errorOxmisc2("Unknown client->type\n");
749: break;
750: }
1.14 takayama 751: oxClientListRemove(client);
1.1 maekawa 752: return(KpoInteger(0));
753:
754: }
755:
756: static int cmoCheck00(struct object obj,int cmo[], int n) {
757: int i,j,m;
758: int ttt;
759: #define CHECK00_N 4098 /* look up stackm.h and kclass.h */
760: static int typeTrans[CHECK00_N];
761: static int init = 0;
1.5 takayama 762: /* if n == 0, report the cmo tag of the object obj.
1.12 takayama 763: If it cannot be translated to cmo, then return -1. */
1.5 takayama 764:
1.1 maekawa 765: if (!init) {
766: for (i=0; i<CHECK00_N; i++) {
767: typeTrans[i] = 0; /* unknown cmo number */
768: }
769: typeTrans[Snull] = CMO_NULL;
770: typeTrans[Sinteger] = CMO_INT32;
771: typeTrans[Sdollar] = CMO_STRING;
772: if (OxVersion >= 199907170) {
773: typeTrans[SuniversalNumber] = CMO_ZZ;
774: }else{
775: typeTrans[SuniversalNumber] = CMO_ZZ_OLD;
776: }
777: typeTrans[Sarray] = CMO_LIST;
778: /* typeTrans[Spoly] = CMO_DMS; */
779: typeTrans[Spoly] = CMO_DISTRIBUTED_POLYNOMIAL;
780: typeTrans[Sdouble] = CMO_64BIT_MACHINE_DOUBLE;
1.20 takayama 781: typeTrans[SrationalFunction] = CMO_RATIONAL;
1.1 maekawa 782: typeTrans[CLASSNAME_ERROR_PACKET] = CMO_ERROR2;
783: typeTrans[CLASSNAME_mathcap] = CMO_MATHCAP;
784: typeTrans[CLASSNAME_indeterminate] = CMO_INDETERMINATE;
785: typeTrans[CLASSNAME_tree] = CMO_TREE;
786: typeTrans[CLASSNAME_recursivePolynomial] = CMO_RECURSIVE_POLYNOMIAL;
787: typeTrans[CLASSNAME_polynomialInOneVariable] = CMO_POLYNOMIAL_IN_ONE_VARIABLE;
788: init = 1;
789: }
790: ttt = typeTrans[obj.tag];
791: if (obj.tag == Sclass) {
792: ttt = typeTrans[ectag(obj)];
793: }
1.5 takayama 794: /* Only report the cmo tag. */
795: if (n == 0) {
1.12 takayama 796: if (ttt == 0) return(-1);
797: else return(ttt);
1.5 takayama 798: }
1.1 maekawa 799:
800: for (i=0; i<n; i++) {
801: if (ttt == cmo[i]) {
802: if (ttt != CMO_LIST) return(1);
803: else {
1.12 takayama 804: m = getoaSize(obj);
805: for (j=0; j<m; j++) {
806: if (!cmoCheck00(getoa(obj,j),cmo,n)) return(0);
807: }
808: return(1);
1.1 maekawa 809: }
810: }
811: }
812: if (DebugMathCap) {
813: if (DebugMathCap && 1) {
814: fprintf(stderr,"Type translation table (internal object tag --> CMO tag)\n");
815: for (i=0; i<20; i++) {
1.12 takayama 816: printf("%d ", typeTrans[i]);
1.1 maekawa 817: }
818: printf("\n");
819: }
820: fprintf(stderr,"The type of the argument object in sm1 is %d.\n",obj.tag);
821: fprintf(stderr,"The type of the argument object in CMO is %d.\n",ttt);
822: fprintf(stderr,"Available CMO tags in mathcap= %d elements : [ ",n);
823: for (i=0; i<n; i++) {
824: fprintf(stderr," %d ",cmo[i]);
825: }
826: fprintf(stderr," ] \n");
827: }
828: return(0);
829: }
830:
831: int cmoCheckMathCap(struct object obj, struct object *obp)
832: {
833: struct object mathcap;
834: struct object cmolist;
1.2 takayama 835: struct object mathcapMain;
1.4 takayama 836: struct object mathcapThird;
837: struct object ox;
838: struct object oxtag;
1.2 takayama 839: struct object ob0;
1.4 takayama 840: int oxsize;
1.1 maekawa 841: int n;
842: int i;
843: #define CMO_CHECK_MATH_CAP_LIST_SIZE 1024
844: int cmo[CMO_CHECK_MATH_CAP_LIST_SIZE];
845: if (obp == NULL) return(1);
1.2 takayama 846: /* printObject(*obp,0,stderr); for debug*/
1.1 maekawa 847: if (obp->tag != Sarray) {
848: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
849: printObject(*obp,0,stderr);
850: fprintf(stderr,"\n");
851: errorOxmisc2("cmoCheckMathCap: format error in the client->mathcapObjp field.\n");
852: }
853: mathcap = *obp;
1.2 takayama 854: /* Example of mathcap
1.12 takayama 855: [ $mathcap-object$ ,
856: [ [ 199909080 , $Ox_system=ox_sm1.plain$ , $Version=2.991106$ ,
857: $HOSTTYPE=i386$ ] ,
858: [ 262 , 263 , 264 , 265 , 266 , 268 , 269 , 272 , 273 , 275 ,
859: 276 ] ,
860: [ [ 514 , [ 2130706434 , 1 , 2 , 4 , 5 , 17 , 19 , 20 , 22 , 23 , 24 , 25 , 26 , 30 , 31 , 60 , 61 , 27 , 33 , 40 , 16 , 34 ] ] ] ] ]
1.2 takayama 861: */
862:
1.1 maekawa 863: n = getoaSize(mathcap);
864: if (n < 2) {
865: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
866: printObject(*obp,0,stderr);
867: fprintf(stderr,"\n");
868: errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n");
869: }
1.2 takayama 870: ob0 = getoa(mathcap,0);
871: if (ob0.tag != Sdollar) {
872: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
873: printObject(*obp,0,stderr);
874: fprintf(stderr,"\n");
875: errorOxmisc2("cmoCheckMathCap: The first field must be the string mathcap-object.\n");
876: }
877: if (strcmp(KopString(ob0),"mathcap-object") != 0) {
878: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
879: printObject(*obp,0,stderr);
880: fprintf(stderr,"\n");
881: errorOxmisc2("cmoCheckMathCap: The mathcap must be of the form [(mathcap-object) [...]]\n");
882: }
883:
1.1 maekawa 884: /* I should check
1.12 takayama 885: getoa(getoa(mathcap,1),2)
1.1 maekawa 886: contains OX_DATA.
887: It has not yet implemented.
888: */
1.2 takayama 889: mathcapMain = getoa(mathcap,1);
890: if (mathcapMain.tag != Sarray) {
891: fprintf(stderr,"cmoCheckMathCap: mathcap[1] is \n");
892: printObject(mathcapMain,0,stderr);
893: fprintf(stderr,"\n");
894: errorOxmisc2("cmoCheckMathCap: format error in the (client->mathcapObjp)[1] field. It should be an array.\n");
895: }
896: if (getoaSize(mathcapMain) < 3) {
897: fprintf(stderr,"cmoCheckMathCap: mathcap[1] is \n");
898: printObject(mathcapMain,0,stderr);
899: fprintf(stderr,"\n");
900: errorOxmisc2("cmoCheckMathCap: format error in the (client->mathcapObjp)[1] field. It should be an array of which length is more than 2.\n");
901: }
1.4 takayama 902: mathcapThird = getoa(mathcapMain,2);
903: oxsize = getoaSize(mathcapThird);
904: for (i=0; i<oxsize; i++) {
905: ox = getoa(mathcapThird,i);
906: if (ox.tag != Sarray) {
907: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
908: printObject(*obp,0,stderr);
909: fprintf(stderr,"\n");
910: errorOxmisc2("cmoCheckMathCap: the third element of mathcap is a list of lists.");
911: }
912: if (getoaSize(ox) != 0) {
913: oxtag = getoa(ox,0);
914: if (oxtag.tag != Sinteger) {
1.12 takayama 915: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
916: printObject(*obp,0,stderr);
917: fprintf(stderr,"\n");
918: errorOxmisc2("cmoCheckMathCap: the third element of mathcap must be [OX_DATA_xxx, [ ]].");
1.4 takayama 919: }
920: if (KopInteger(oxtag) == OX_DATA) {
1.12 takayama 921: if (getoaSize(ox) > 1) {
922: cmolist = getoa(ox,1);
923: if (cmolist.tag != Sarray) {
924: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
925: printObject(*obp,0,stderr);
926: fprintf(stderr,"\n");
927: errorOxmisc2("cmoCheckMathCap: mathcap[1] must be an array of integers.\n");
928: }
929: n = getoaSize(cmolist);
930: if (n > CMO_CHECK_MATH_CAP_LIST_SIZE) {
931: errorOxmisc2("cmoCheckMathCap: Too big cmo list.\n");
932: }
933: for (i=0; i<n; i++) {
934: cmo[i] = KopInteger(getoa(cmolist,i));
935: }
936: }else{
937: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
938: printObject(*obp,0,stderr);
939: fprintf(stderr,"\nox=");
940: printObject(ox,0,stderr);
941: errorOxmisc2("cmoCheckMathCap: [OX_DATA, cmolist]");
942: }
1.4 takayama 943: }
944: }
1.1 maekawa 945: }
946: return(cmoCheck00(obj,cmo,n));
947: }
948:
1.12 takayama 949:
1.1 maekawa 950: struct object KoxGenPortFile(void) {
951: struct object ob;
952: ob = KpoString(oxGenPortFile());
953: return(ob);
954: }
955: void KoxRemovePortFile(void) {
956: oxRemovePortFile();
957: }
958:
959: void oxPushMathCap(struct mathCap *mathcap)
960: {
961: struct object rob;
962: rob = newMathCap(mathcap);
963: Kpush(rob);
964: }
965:
966: struct object KoxGenPass(void) {
967: struct object rob;
968: rob = KpoString(oxGenPass());
969: return(rob);
970: }
971:
972: struct object KoxGetPort(struct object host)
973: {
974: struct object rob;
975: int fdStream, fdControl;
976: int portStream, portControl;
977: extern int OpenedSocket;
978: char *sname;
979: rob = NullObject;
980: if (host.tag != Sdollar) {
981: errorOxmisc2("KoxGetPort: argument is not a string.");
982: return(rob);
983: }
984: sname = KopString(host);
985: fdControl = socketOpen(sname,0);
986: portControl = OpenedSocket;
987: fdStream = socketOpen(sname,0);
988: portStream = OpenedSocket;
989: rob = newObjectArray(4);
990: putoa(rob,0,KpoInteger(fdStream));
991: putoa(rob,1,KpoInteger(portStream));
992: putoa(rob,2,KpoInteger(fdControl));
993: putoa(rob,3,KpoInteger(portControl));
1.10 takayama 994: return(rob);
995: }
996: struct object KoxGetPort1(struct object host)
997: {
998: struct object rob;
999: int fdStream;
1000: int portStream;
1001: extern int OpenedSocket;
1002: char *sname;
1003: rob = NullObject;
1004: if (host.tag != Sdollar) {
1005: errorOxmisc2("KoxGetPort1: argument is not a string.");
1006: return(rob);
1007: }
1008: sname = KopString(host);
1009: fdStream = socketOpen(sname,0);
1010: portStream = OpenedSocket;
1011: rob = newObjectArray(2);
1012: putoa(rob,0,KpoInteger(fdStream));
1013: putoa(rob,1,KpoInteger(portStream));
1.1 maekawa 1014: return(rob);
1015: }
1016:
1017: struct object KoxCreateClient2(struct object peer,
1.12 takayama 1018: struct object ipmask,
1019: struct object pass)
1.1 maekawa 1020: {
1021: struct object rob;
1022: oxclientp client;
1023: int fdStream, portStream, fdControl, portControl;
1024: int i;
1025: struct object ob1;
1026: rob.tag = Snull;
1027: if (peer.tag != Sarray) {
1028: errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl]");
1029: return(rob);
1030: }
1031: if (getoaSize(peer) != 4) {
1032: errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl] of size 4.");
1033: return(rob);
1034: }
1035: for (i=0; i<4; i++) {
1036: ob1 = getoa(peer,i);
1037: if (ob1.tag != Sinteger) {
1038: errorOxmisc2("KoxCreateClient2(): The element of the first argument must be an integer.");
1039: }
1040: }
1041: fdStream = KopInteger(getoa(peer,0));
1042: portStream = KopInteger(getoa(peer,1));
1043: fdControl = KopInteger(getoa(peer,2));
1044: portControl = KopInteger(getoa(peer,3));
1045:
1046: if (ipmask.tag != Sinteger) {
1047: errorOxmisc2("KoxCreateClient2(): ipmask must be an integer.");
1048: }
1049: if (pass.tag != Sdollar) {
1050: errorOxmisc2("KoxCreateClient2(): pass must be a string.");
1051: }
1052:
1053: client = oxCreateClient2(fdStream, portStream, fdControl, portControl,
1.12 takayama 1054: KopInteger(ipmask), KopString(pass));
1.1 maekawa 1055: if (client == NULL) {
1056: errorOxmisc2("KoxCreateClient2(): Open error.");
1057: return(rob);
1058: }
1059: rob = newObjectArray(N_OF_CLIENT_FIELDS);
1060: oxClientToObject(client,rob);
1.14 takayama 1061: oxClientListUpdate(rob);
1.1 maekawa 1062: return(rob);
1.5 takayama 1063: }
1064:
1065: int KgetCmoTagOfObject(struct object obj) {
1066: int k;
1067: k=cmoCheck00(obj,(int *)NULL,0);
1068: return(k);
1.1 maekawa 1069: }
1070:
1071: errorOxmisc2(char *s) {
1.6 takayama 1072: SET_MYERROROUT;
1.1 maekawa 1073: fprintf(MyErrorOut,"error in oxmisc2.c: %s\n",s);
1074: errorKan1("%s\n"," ");
1.7 takayama 1075: }
1076:
1077: struct object KoxPushCMD(struct object client,struct object cmd) {
1078: int ans;
1079: static oxclientp cc1 = NULL;
1080: struct object rob;
1081: rob.tag = Snull;
1082: if (cc1 == NULL) {
1083: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
1084: if (cc1 == NULL) {
1085: errorOxmisc2("KoxReq(): no more memory.");
1086: return(rob);
1087: }
1088: oxInitClient(cc1); /* BUG: is it fine? */
1089: }
1090:
1091: if (oxObjectToClient(client,cc1) == -1) return(rob);
1092: if (cc1 == NULL) {
1093: errorOxmisc2("KoxReq(): the first argument must be a client object.");
1094: return(rob);
1095: }
1096: if (cmd.tag != Sinteger) {
1097: errorOxmisc2("KoxReq(): the second argument must be an integer.");
1098: return(rob);
1099: }
1100: /* BUG: check the mathcap */
1101: oxSendOXheader(cc1->datafp2,OX_COMMAND,SerialOX++);
1102: oxSendInt32(cc1->datafp2,KopInteger(cmd));
1103: /* synchronize cc1 and client. */
1104: oxClientToObject(cc1,client);
1105: return(cmd);
1106: }
1107:
1108: struct object KoxPushCMO(struct object client,struct object ob) {
1109: int ans;
1110: static oxclientp cc1 = NULL;
1111: struct object rob;
1112: rob.tag = Snull;
1113: if (cc1 == NULL) {
1114: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
1115: if (cc1 == NULL) {
1116: errorOxmisc2("KoxReq(): no more memory.");
1117: return(rob);
1118: }
1119: oxInitClient(cc1); /* BUG: is it fine? */
1120: }
1121:
1122: if (oxObjectToClient(client,cc1) == -1) return(rob);
1123: if (cc1 == NULL) {
1124: errorOxmisc2("KoxReq(): the first argument must be a client object.");
1125: return(rob);
1126: }
1127:
1128: /* request to the data channel */
1129: if (cc1->dstate != DSTATE_ANY) {
1130: errorOxmisc2("oxPushCMO: cc1->dstate != DSTATE_ANY, data channel is not ready to send data.\n");
1131: return(rob);
1132: }
1133:
1134: if (!cmoCheckMathCap(ob,(struct object *)cc1->mathcapObjp)) {
1.12 takayama 1135: errorOxmisc2("oxPushCMO: your peer does not understand this cmo.\n");
1136: return(rob);
1.7 takayama 1137: }
1138: oxSendOXheader(cc1->datafp2,OX_DATA,SerialOX++);
1139: cmoObjectToStream2(ob,cc1->datafp2);
1140: /* synchronize cc1 and client. */
1141: oxClientToObject(cc1,client);
1142: return(ob);
1.8 takayama 1143: }
1144:
1145: oxclientp oxCreateControl_RFC_101(int fdstream,int portStream,
1.12 takayama 1146: int ipmask,char *pass);
1.8 takayama 1147: struct object KoxCreateControl_RFC_101(struct object peer,struct object ipmask,struct object pass)
1148: {
1149: struct object rob;
1150: oxclientp client;
1151: int fdStream, portStream;
1152: int i;
1153: struct object ob1;
1154: rob.tag = Snull;
1155: if (peer.tag != Sarray) {
1156: errorOxmisc2("KoxCreateControl_RFC_101(): The first argument must be an array [fdStream, portStream]");
1157: return(rob);
1158: }
1159: if (getoaSize(peer) != 2 ) {
1160: errorOxmisc2("KoxCreateControl_RFC_101(): The first argument must be an array [fdStream, portStream] of size 2.");
1161: return(rob);
1162: }
1163: for (i=0; i<getoaSize(peer); i++) {
1164: ob1 = getoa(peer,i);
1165: if (ob1.tag != Sinteger) {
1166: errorOxmisc2("KoxCreateControl_RFC_101(): The element of the first argument must be an integer.");
1167: }
1168: }
1169: fdStream = KopInteger(getoa(peer,0));
1170: portStream = KopInteger(getoa(peer,1));
1171:
1172: if (ipmask.tag != Sinteger) {
1173: errorOxmisc2("KoxCreateControl_RFC_101(): ipmask must be an integer.");
1174: }
1175: if (pass.tag != Sdollar) {
1176: errorOxmisc2("KoxCreateControl_RFC_101(): pass must be a string.");
1177: }
1178:
1179: client = oxCreateControl_RFC_101(fdStream, portStream,
1.12 takayama 1180: KopInteger(ipmask), KopString(pass));
1.8 takayama 1181: if (client == NULL) {
1182: errorOxmisc2("KoxCreateControl_RFC_101(): Open error.");
1183: return(rob);
1184: }
1185: rob = newObjectArray(N_OF_CLIENT_FIELDS);
1186: oxClientToObject(client,rob);
1187: return(rob);
1188: }
1189:
1190: oxclientp oxCreateControl_RFC_101(int fdstream,int portStream,
1.12 takayama 1191: int ipmask,char *pass)
1.8 takayama 1192: {
1193: int v = 0;
1194: int fdControl = -1;
1195: int fdStream = -1;
1196: int m;
1197:
1198: char *s;
1199: oxclientp client;
1.13 takayama 1200: #if defined(__CYGWIN__)
1201: extern sigjmp_buf MyEnv_oxmisc;
1202: #else
1203: extern jmp_buf MyEnv_oxmisc;
1204: #endif
1.8 takayama 1205: int engineByteOrder;
1206: extern int Quiet;
1207:
1208: v = !Quiet;
1209:
1210: switch(ipmask) {
1211: case 0:/* only local */
1212: fdStream = socketAcceptLocal(fdstream);
1213: break;
1214: default:/* any */
1215: fdStream = socketAccept(fdstream);
1216: break;
1217: }
1218: if (v) fprintf(stderr,"\nControl port %d : Connected.\n",portStream);
1219:
1220: if (fdStream == -1 ) {
1221: fprintf(stderr,"\nOpen error in oxCreateControl_RFC_101.\n");
1222: return(NULL);
1223: }
1224:
1225: /* Authentication by password. */
1226: m = strlen(pass);
1227: s = (char *)mymalloc(sizeof(char)*(m+1));
1228: read(fdStream,s,m+1); s[m] = '\0';
1229: if (strcmp(s,pass) != 0) {
1230: fprintf(stderr,"oxCreateControl_RFC_101(): password authentication failed for control channel.\n");
1231: close(fdStream);
1232: return(NULL);
1233: }
1234:
1235:
1236: engineByteOrder = oxSetByteOrder(fdStream);
1237: if (v) fprintf(stderr,"Byte order for control stackmacine is %s.\n",
1.12 takayama 1238: (engineByteOrder == 0? "network byte order":
1239: (engineByteOrder == 1? "little indican":
1240: "big indian")));
1.8 takayama 1241:
1242:
1243: client = (oxclientp) mymalloc(sizeof(oxclient));
1244: oxInitClient(client);
1245: client->datafp2 = fp2open(fdStream);
1246: if (client->datafp2 == NULL) {
1247: fprintf(stderr,"oxCreateControl_RFC_101(): fp2open(fd) failed.\n");
1248: return(NULL);
1249: }
1250: client->dataport = portStream;
1251: client->controlport = -1;
1252: client->controlfd = -1;
1.14 takayama 1253: client->id = oxGetClientID();
1.11 takayama 1254: client->type = CLIENT_SOCKET; /* socket */
1255: client->engineByteOrder = engineByteOrder;
1256: client->controlByteOrder = -1;
1257: return(client);
1258: }
1259:
1260: oxclientp oxCreateEngine_RFC_101(int fdstream,int portStream,
1.12 takayama 1261: int ipmask,char *pass, int engineID);
1.11 takayama 1262: struct object KoxCreateEngine_RFC_101(struct object peer,struct object ipmask,struct object pass, struct object engineID)
1263: {
1264: struct object rob;
1265: oxclientp client;
1266: int fdStream, portStream;
1267: int i;
1268: struct object ob1;
1269: rob.tag = Snull;
1270: if (peer.tag != Sarray) {
1271: errorOxmisc2("KoxCreateEngine_RFC_101(): The first argument must be an array [fdStream, portStream]");
1272: return(rob);
1273: }
1274: if (getoaSize(peer) != 2 ) {
1275: errorOxmisc2("KoxCreateEngine_RFC_101(): The first argument must be an array [fdStream, portStream] of size 2.");
1276: return(rob);
1277: }
1278: for (i=0; i<getoaSize(peer); i++) {
1279: ob1 = getoa(peer,i);
1280: if (ob1.tag != Sinteger) {
1281: errorOxmisc2("KoxCreateEngine_RFC_101(): The element of the first argument must be an integer.");
1282: }
1283: }
1284: fdStream = KopInteger(getoa(peer,0));
1285: portStream = KopInteger(getoa(peer,1));
1286:
1287: if (ipmask.tag != Sinteger) {
1288: errorOxmisc2("KoxCreateEngine_RFC_101(): ipmask must be an integer.");
1289: }
1290: if (pass.tag != Sdollar) {
1291: errorOxmisc2("KoxCreateEngine_RFC_101(): pass must be a string.");
1292: }
1293: if (engineID.tag != Sinteger) {
1294: errorOxmisc2("KoxCreateEngine_RFC_101(): engineID must be an integer.");
1295: }
1296:
1297: client = oxCreateEngine_RFC_101(fdStream, portStream,
1.12 takayama 1298: KopInteger(ipmask), KopString(pass),KopInteger(engineID));
1.11 takayama 1299: if (client == NULL) {
1300: errorOxmisc2("KoxCreateEngine_RFC_101(): Open error.");
1301: return(rob);
1302: }
1303: rob = newObjectArray(N_OF_CLIENT_FIELDS);
1304: oxClientToObject(client,rob);
1.14 takayama 1305: oxClientListUpdate(rob);
1.11 takayama 1306: return(rob);
1307: }
1308:
1309: oxclientp oxCreateEngine_RFC_101(int fdstream,int portStream,
1.12 takayama 1310: int ipmask,char *pass,int engineID)
1.11 takayama 1311: {
1312: int v = 0;
1313: int fdControl = -1;
1314: int fdStream = -1;
1315: int m;
1316:
1317: char *s;
1318: oxclientp client;
1.13 takayama 1319: #if defined(__CYGWIN__)
1320: extern sigjmp_buf MyEnv_oxmisc;
1321: #else
1322: extern jmp_buf MyEnv_oxmisc;
1323: #endif
1.11 takayama 1324: int engineByteOrder;
1325: extern int Quiet;
1326:
1327: v = !Quiet;
1328:
1329: switch(ipmask) {
1330: case 0:/* only local */
1331: fdStream = socketAcceptLocal(fdstream);
1332: break;
1333: default:/* any */
1334: fdStream = socketAccept(fdstream);
1335: break;
1336: }
1337: if (v) fprintf(stderr,"\nEngine port %d : Connected.\n",portStream);
1338:
1339: if (fdStream == -1 ) {
1340: fprintf(stderr,"\nOpen error in oxCreateEngine_RFC_101.\n");
1341: return(NULL);
1342: }
1343:
1344: /* Authentication by password. */
1345: /* skip password check for now. BUG.
1.12 takayama 1346: m = strlen(pass);
1347: s = (char *)mymalloc(sizeof(char)*(m+1));
1348: read(fdStream,s,m+1); s[m] = '\0';
1349: if (strcmp(s,pass) != 0) {
1350: fprintf(stderr,"oxCreateEngine_RFC_101(): password authentication failed for control channel.\n");
1351: close(fdStream);
1352: return(NULL);
1353: }
1.11 takayama 1354: */
1355:
1356: engineByteOrder = oxSetByteOrder(fdStream);
1357: if (v) fprintf(stderr,"Byte order for engine stackmacine is %s.\n",
1.12 takayama 1358: (engineByteOrder == 0? "network byte order":
1359: (engineByteOrder == 1? "little indican":
1360: "big indian")));
1.11 takayama 1361:
1362:
1363: client = (oxclientp) mymalloc(sizeof(oxclient));
1364: oxInitClient(client);
1365: client->datafp2 = fp2open(fdStream);
1366: if (client->datafp2 == NULL) {
1367: fprintf(stderr,"oxCreateEngine_RFC_101(): fp2open(fd) failed.\n");
1368: return(NULL);
1369: }
1370: client->dataport = portStream;
1371: client->controlport = -1;
1372: client->controlfd = -1;
1.16 takayama 1373: client->id = oxGetClientID();
1374: client->engineID = engineID;
1.8 takayama 1375: client->type = CLIENT_SOCKET; /* socket */
1376: client->engineByteOrder = engineByteOrder;
1377: client->controlByteOrder = -1;
1378: return(client);
1.1 maekawa 1379: }
1.14 takayama 1380:
1381: void oxClientListUpdate(struct object ob) {
1382: int id;
1383: extern struct object OxClientList[];
1384: id = KopInteger(getoa(ob,8));
1385: /* printf("id=%d\n",id); */
1386: if ((id <MAX_N_OF_CLIENT) && (id >= 0)) {
1387: OxClientList[id] = ob;
1388: }else{
1389: errorOxmisc2("oxClientListUpdate(): the client table is full.\n");
1390: }
1391: }
1392: void oxClientListRemove(struct object ob) {
1393: int id;
1394: extern struct object OxClientList[];
1395: id = KopInteger(getoa(ob,8));
1396: if ((id <MAX_N_OF_CLIENT) && (id >= 0)) {
1397: (OxClientList[id]).tag = Snull;
1398: }else{
1399: /* errorOxmisc2("oxClientListRemove(): the client table is full.\n");*/
1400: }
1401: }
1.17 takayama 1402: static void KoxCleanClientList() {
1403: extern int OxClientListn;
1404: extern struct object OxClientList[];
1405: int i,j,n;
1406: struct object ob;
1407: n = 0;
1408: for (i=0; i<OxClientListn; i++) {
1409: if ((OxClientList[i]).tag != Snull) {
1410: if (!isItClientObject(OxClientList[i])) {
1411: (OxClientList[i]).tag = Snull;
1412: }
1413: }
1414: }
1415: }
1.14 takayama 1416: struct object KoxGetClientList() {
1417: extern int OxClientListn;
1418: extern struct object OxClientList[];
1419: int i,j,n;
1420: struct object rob;
1.17 takayama 1421: KoxCleanClientList();
1.14 takayama 1422: n = 0;
1423: for (i=0; i<OxClientListn; i++) {
1424: if ((OxClientList[i]).tag != Snull) n++;
1425: }
1426: rob = newObjectArray(n);
1427: for (i=0, j=0; i<OxClientListn; i++) {
1428: if ((OxClientList[i]).tag != Snull) {
1429: if (j >= n) {
1430: j=0;
1431: errorOxmisc2("oxGetClientList(): the client table is broken.\n");
1432: }
1433: putoa(rob,j,OxClientList[i]);
1434: j++;
1435: }
1436: }
1437: return rob;
1438: }
1439:
1440:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to oxmisc2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / plugin