Annotation of OpenXM/src/kan96xx/plugin/Old/oxmisc2.c, Revision 1.1
1.1 ! maekawa 1: #include <stdio.h>
! 2: #include "ox_kan.h"
! 3: #include "oxmisc2.h" /* This file requires sm1 object description. */
! 4: extern FILE *MyErrorOut;
! 5:
! 6: int oxGet(oxclientp client, struct object *op,int *isObj)
! 7: /* This method should be synchronized. */
! 8: /* oxGet is a function for client. */
! 9: {
! 10: int ans;
! 11: ox_stream os;
! 12: int m;
! 13: struct object rob;
! 14: *isObj = 0;
! 15: op->tag = Snull;
! 16: os = client->datafp2;
! 17: switch(client->dstate) {
! 18: case DSTATE_ANY:
! 19: m = oxGetInt32(os);
! 20: switch(m) {
! 21: case OX_DATA:
! 22: client->dstate = DSTATE_WAIT_OX_DATA;
! 23: return(oxGet(client,op,isObj));
! 24: case OX_SYNC_BALL:
! 25: client->dstate = DSTATE_ANY;
! 26: return(OX_SYNC_BALL);
! 27: default:
! 28: errorOxmisc2("oxGet: cannot handle this tag.\n");
! 29: client->dstate = DSTATE_ERROR;
! 30: return(-1);
! 31: }
! 32: break;
! 33: case DSTATE_FIRST_SYNC: /* waiting the first sync ball */
! 34: /* I need to clear the buffer?? */
! 35: oxWaitSyncBall(os);
! 36: client->dstate = DSTATE_ANY;
! 37: oxSendSyncBall(os);
! 38: return(OX_SYNC_BALL);
! 39: break;
! 40: case DSTATE_WAIT_OX_DATA: /* waiting a cmo data. */
! 41: *op = cmoObjectFromStream2(client->datafp2);
! 42: client->dstate = DSTATE_ANY;
! 43: *isObj = 1;
! 44: return(0);
! 45: break;
! 46: case DSTATE_ERROR:
! 47: client->dstate = DSTATE_ERROR;
! 48: errorOxmisc2("oxGet: dstate == DSTATE_ERROR (error state)\n");
! 49: return(-1);
! 50: default:
! 51: client->dstate = DSTATE_ERROR;
! 52: errorOxmisc2("oxGet: Unknown state number.");
! 53: }
! 54:
! 55: return(-1);
! 56: }
! 57:
! 58: int oxGetFromControl(oxclientp client)
! 59: {
! 60: int ans = -1;
! 61: if (client->cstate != -1) {
! 62: ans = oxGetResultOfControlInt32(client->controlfd);
! 63: if (ans != -1) { client->cstate = 0; }
! 64: else {client->cstate = -1; }
! 65: }
! 66: return(ans);
! 67: }
! 68:
! 69: int oxReq(oxclientp client,int func,struct object ob)
! 70: {
! 71: /* request to the control channel */
! 72: if (func == SM_control_reset_connection ||
! 73: func == SM_control_kill) {
! 74: switch(func) {
! 75: case SM_control_reset_connection:
! 76: oxReqControlResetConnection(client->controlfd);
! 77: client->cstate = 1;
! 78: client->dstate = DSTATE_FIRST_SYNC;
! 79: break;
! 80: case SM_control_kill:
! 81: oxReqControlKill(client->controlfd);
! 82: client->cstate = 0;
! 83: client->dstate = DSTATE_ANY;
! 84: break;
! 85: }
! 86: fflush(NULL);
! 87: return(0);
! 88: }
! 89:
! 90: /* request to the data channel */
! 91: if (client->dstate != DSTATE_ANY) {
! 92: errorOxmisc2("oxReq: client->dstate != DSTATE_ANY, data channel is not ready to send data.\n");
! 93: return(-1);
! 94: }
! 95: switch(func) {
! 96: case SM_DUMMY_sendcmo:
! 97: oxSendInt32(client->datafp2,OX_DATA);
! 98: cmoObjectToStream2(ob,client->datafp2);
! 99: client->dstate = DSTATE_ANY;
! 100: break;
! 101: case SM_sync_ball:
! 102: oxSendSyncBall(client->datafp2);
! 103: client->dstate = DSTATE_ANY; /* We do not expect the sync ball.*/
! 104: client->cstate = 0; /* clear the cstate */
! 105: break;
! 106: case SM_popCMO:
! 107: oxReqPopCMO(client->datafp2);
! 108: client->dstate = DSTATE_ANY;
! 109: break;
! 110: case SM_mathcap:
! 111: oxReqMathCap(client->datafp2);
! 112: client->dstate = DSTATE_ANY;
! 113: break;
! 114: case SM_pops:
! 115: if (ob.tag != Sinteger) {
! 116: errorOxmisc2("SM_pops : the argument must be an integer.");
! 117: return(-1);
! 118: }
! 119: oxReqPops(client->datafp2, KopInteger(ob));
! 120: client->dstate = DSTATE_ANY;
! 121: break;
! 122: case SM_executeStringByLocalParser:
! 123: if (ob.tag != Sdollar) {
! 124: errorOxmisc2("SM_executeStringByLocalParser : the argument must be a string.");
! 125: return(-1);
! 126: }
! 127: oxReqExecuteStringByLocalParser(client->datafp2,KopString(ob));
! 128: client->dstate = DSTATE_ANY;
! 129: break;
! 130: case SM_executeFunction:
! 131: if (ob.tag != Sdollar) {
! 132: errorOxmisc2("SM_executeFunction : the argument must be a string.");
! 133: return(-1);
! 134: }
! 135: oxReqExecuteFunction(client->datafp2,KopString(ob));
! 136: client->dstate = DSTATE_ANY;
! 137: break;
! 138: case SM_popString:
! 139: oxReqPopString(client->datafp2);
! 140: client->dstate = DSTATE_ANY;
! 141: break;
! 142: case SM_evalName:
! 143: if (ob.tag != Sdollar) {
! 144: errorOxmisc2("SM_evalName : the argument must be a string.");
! 145: return(-1);
! 146: }
! 147: oxReqEvalName(client->datafp2,KopString(ob));
! 148: client->dstate = DSTATE_ANY;
! 149: break;
! 150: case SM_setName:
! 151: if (ob.tag != Sdollar) {
! 152: errorOxmisc2("SM_setName : the argument must be a string.");
! 153: return(-1);
! 154: }
! 155: oxReqSetName(client->datafp2,KopString(ob));
! 156: client->dstate = DSTATE_ANY;
! 157: break;
! 158: default:
! 159: fprintf(MyErrorOut,"func=%d ",func);
! 160: errorOxmisc2("This function is not implemented.");
! 161: break;
! 162: }
! 163: fp2fflush(client->datafp2);
! 164: return(0);
! 165: }
! 166:
! 167: struct object KoxCreateClient(struct object ip,
! 168: struct object portStream,
! 169: struct object portControl)
! 170: {
! 171: struct object rob;
! 172: oxclientp client;
! 173: rob.tag = Snull;
! 174: if (ip.tag != Sdollar) {
! 175: errorOxmisc2("KoxCreateClient(): The first argument must be a hostname given by a string.");
! 176: return(rob);
! 177: }
! 178: if (portStream.tag == Sdollar) {
! 179: client = oxCreateClientFile(KopString(ip),KopString(portStream),
! 180: "/dev/null","w");
! 181: if (client == NULL) {
! 182: errorOxmisc2("KoxCreateClient(): Open error.");
! 183: return(rob);
! 184: }
! 185: rob = newObjectArray(N_OF_CLIENT_FIELDS);
! 186: oxClientToObject(client,rob);
! 187: return(rob);
! 188: }
! 189:
! 190: if (portStream.tag != Sinteger) {
! 191: errorOxmisc2("KoxCreateClient(): The second argument must be a port number given in an integer.");
! 192: return(rob);
! 193: }
! 194: if (portControl.tag != Sinteger) {
! 195: errorOxmisc2("KoxCreateClient(): The third argument must be a port number given in an integer.");
! 196: return(rob);
! 197: }
! 198: client = oxCreateClient(KopString(ip),KopInteger(portStream),KopInteger(portControl));
! 199: if (client == NULL) {
! 200: errorOxmisc2("KoxCreateClient(): Open error.");
! 201: return(rob);
! 202: }
! 203: rob = newObjectArray(N_OF_CLIENT_FIELDS);
! 204: oxClientToObject(client,rob);
! 205: return(rob);
! 206: }
! 207:
! 208: static int isItClientObject(struct object ob)
! 209: {
! 210: int size,i;
! 211: struct object ee[N_OF_CLIENT_FIELDS];
! 212: if (ob.tag != Sarray) {
! 213: return(0);
! 214: }
! 215: size = getoaSize(ob);
! 216: if (size != N_OF_CLIENT_FIELDS) return(0);
! 217: for (i=0; i<N_OF_CLIENT_FIELDS; i++) {
! 218: ee[i] = getoa(ob,i);
! 219: }
! 220:
! 221: if (ee[0].tag != Sdollar) return(0);
! 222: if (strcmp(KopString(ee[0]),"client")!=0) return(0);
! 223:
! 224: if (ee[1].tag != Sfile) return(0);
! 225: if (strcmp((ee[1]).lc.str,MAGIC2) != 0) return(0);
! 226:
! 227: for (i=2; i<N_OF_CLIENT_FIELDS; i++) {
! 228: if (ee[i].tag != Sinteger) return(0);
! 229: }
! 230: return(1);
! 231: }
! 232:
! 233:
! 234: struct object KoxIsThereErrorClient(struct object ob)
! 235: {
! 236: struct object rob;
! 237: int ans;
! 238: int size;
! 239: oxclient cc;
! 240: rob.tag = Snull;
! 241: if (!isItClientObject(ob)) {
! 242: errorOxmisc2("KoxIsThereErrorClient(): the argument must be an array for client object.");
! 243: return(rob);
! 244: }
! 245: if (oxObjectToClient(ob,&cc) == -1) return(KpoInteger(-1));
! 246: ans = oxIsThereErrorClient(&cc);
! 247: return(KpoInteger(ans));
! 248: }
! 249:
! 250: int oxClientToObject(oxclientp client,struct object rob)
! 251: {
! 252: struct object ob;
! 253: if (client == NULL) return;
! 254: /* rob = newObjectArray(N_OF_CLIENT_FIELDS); */
! 255: if (rob.tag != Sarray) {
! 256: errorOxmisc2("oxClientToObject(): the second argument must be an array.");
! 257: return(-1);
! 258: }
! 259: if (getoaSize(rob) != N_OF_CLIENT_FIELDS) {
! 260: errorOxmisc2("oxClientToObject(): the second argument must be an array of size N_OF_CLIENT_FIELDS.");
! 261: return(-1);
! 262: }
! 263:
! 264: ob = KpoString("client");
! 265: putoa(rob,0,ob);
! 266:
! 267: ob.tag = Sfile; ob.lc.str = MAGIC2; ob.rc.voidp = (void *)(client->datafp2);
! 268: putoa(rob,1,ob);
! 269:
! 270: putoa(rob,2,KpoInteger(client->dataport));
! 271: putoa(rob,3,KpoInteger(client->controlfd));
! 272: putoa(rob,4,KpoInteger(client->controlport));
! 273: putoa(rob,5,KpoInteger(client->dstate));
! 274: putoa(rob,6,KpoInteger(client->cstate));
! 275: putoa(rob,7,KpoInteger(client->humanio));
! 276: putoa(rob,8,KpoInteger(client->id));
! 277: putoa(rob,9,KpoInteger(client->type));
! 278: return(0);
! 279: }
! 280:
! 281: int oxObjectToClient(struct object ob,oxclientp cp)
! 282: {
! 283: struct object ob1;
! 284: if (cp == NULL) {
! 285: errorOxmisc2("oxObjectToClient(): the second argument is NULL");
! 286: return(-1);
! 287: }
! 288: if (!isItClientObject(ob)) {
! 289: errorOxmisc2("oxObjectToClient(): the first argument is not client object.");
! 290: oxInitClient(cp);
! 291: return(-1);
! 292: }
! 293:
! 294: ob1 = getoa(ob,1);
! 295: cp->datafp2 = (FILE2 *) (ob1.rc.voidp);
! 296:
! 297: ob1 = getoa(ob,2);
! 298: cp->dataport = KopInteger(ob1);
! 299:
! 300: ob1 = getoa(ob,3);
! 301: cp->controlfd = KopInteger(ob1);
! 302:
! 303: ob1 = getoa(ob,4);
! 304: cp->controlport = KopInteger(ob1);
! 305:
! 306: ob1 = getoa(ob,5);
! 307: cp->dstate = KopInteger(ob1);
! 308:
! 309: ob1 = getoa(ob,6);
! 310: cp->cstate = KopInteger(ob1);
! 311:
! 312: ob1 = getoa(ob,7);
! 313: cp->humanio = KopInteger(ob1);
! 314:
! 315: ob1 = getoa(ob,8);
! 316: cp->id = KopInteger(ob1);
! 317:
! 318: ob1 = getoa(ob,9);
! 319: cp->type = KopInteger(ob1);
! 320:
! 321: return(0);
! 322: }
! 323:
! 324: struct object KoxReq(struct object client,
! 325: struct object func,
! 326: struct object ob1)
! 327: {
! 328: int ans;
! 329: static oxclientp cc1 = NULL;
! 330: struct object rob;
! 331: rob.tag = Snull;
! 332: if (cc1 == NULL) {
! 333: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 334: if (cc1 == NULL) {
! 335: errorOxmisc2("KoxReq(): no more memory.");
! 336: return(rob);
! 337: }
! 338: oxInitClient(cc1);
! 339: }
! 340:
! 341: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 342: if (cc1 == NULL) {
! 343: errorOxmisc2("KoxReq(): the first argument must be a client object.");
! 344: return(rob);
! 345: }
! 346: if (func.tag != Sinteger) {
! 347: errorOxmisc2("KoxReq(): the second argument must be an integer.");
! 348: return(rob);
! 349: }
! 350: ans = oxReq(cc1,KopInteger(func),ob1);
! 351: /* synchronize cc1 and client. */
! 352: oxClientToObject(cc1,client);
! 353:
! 354: return(KpoInteger(ans));
! 355: }
! 356:
! 357: struct object KoxGet(struct object client)
! 358: {
! 359: int ans,k;
! 360: static oxclientp cc1 = NULL;
! 361: struct object rob;
! 362: rob.tag = Snull;
! 363: if (cc1 == NULL) {
! 364: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 365: if (cc1 == NULL) {
! 366: errorOxmisc2("KoxGet(): no more memory.");
! 367: return(rob);
! 368: }
! 369: oxInitClient(cc1);
! 370: }
! 371:
! 372: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 373: if (cc1 == NULL) {
! 374: errorOxmisc2("KoxGet(): the first argument must be a client object.");
! 375: return(rob);
! 376: }
! 377:
! 378: ans = oxGet(cc1,&rob,&k);
! 379: /* synchronize cc1 and client. */
! 380: oxClientToObject(cc1,client);
! 381:
! 382: if (k) return(rob);
! 383: else {
! 384: return(KpoInteger(ans));
! 385: }
! 386: }
! 387:
! 388: struct object KoxGetFromControl(struct object client)
! 389: {
! 390: int ans;
! 391: static oxclientp cc1 = NULL;
! 392: struct object rob;
! 393: rob.tag = Snull;
! 394: if (cc1 == NULL) {
! 395: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 396: if (cc1 == NULL) {
! 397: errorOxmisc2("KoxGetFromControl(): no more memory.");
! 398: return(rob);
! 399: }
! 400: oxInitClient(cc1);
! 401: }
! 402:
! 403: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 404: if (cc1 == NULL) {
! 405: errorOxmisc2("KoxGetFromControl(): the first argument must be a client object.");
! 406: return(rob);
! 407: }
! 408:
! 409: ans = oxGetFromControl(cc1);
! 410: /* synchronize cc1 and client. */
! 411: oxClientToObject(cc1,client);
! 412:
! 413: return(KpoInteger(ans));
! 414: }
! 415:
! 416: struct object KoxMultiSelect(struct object oclients,struct object t)
! 417: {
! 418: static int first = 1;
! 419: static int csize = 0;
! 420: static oxclientp *clients = NULL;
! 421: oxclientp cc1;
! 422: struct object rob;
! 423: int i;
! 424: int tt;
! 425: struct object ob1;
! 426: struct object ob2;
! 427: struct object ob0;
! 428: int size;
! 429: int ans;
! 430: int dataready[1024];
! 431: int controlready[1024];
! 432:
! 433: rob.tag = Snull;
! 434: if (oclients.tag != Sarray) {
! 435: errorOxmisc2("KoxMultiSelect(): the first argument must be an array.");
! 436: return(rob);
! 437: }
! 438: size = getoaSize(oclients);
! 439: if (first) {
! 440: first = 0; csize = size;
! 441: clients = (oxclientp *)mymalloc(sizeof(oxclientp)*(size+1));
! 442: if (clients == NULL) {
! 443: errorOxmisc2("KoxMultiSelect(): no more memory.");
! 444: return(rob);
! 445: }
! 446: for (i=0; i<size; i++) {
! 447: clients[i] = (oxclientp) mymalloc(sizeof(oxclient));
! 448: if (clients[i] == NULL) {
! 449: errorOxmisc2("KoxMultiSelect(): no more memory.");
! 450: return(rob);
! 451: }
! 452: oxInitClient(clients[i]);
! 453: }
! 454: }
! 455: if (csize < size) {
! 456: first = 1;
! 457: return(KoxMultiSelect(oclients,t));
! 458: }
! 459: for (i=0; i<size; i++) {
! 460: ob0 = getoa(oclients,i);
! 461: if (oxObjectToClient(ob0,clients[i]) == -1) return(rob);
! 462: }
! 463: if (t.tag != Sinteger) {
! 464: errorOxmisc2("KoxMultiSelect(): the second argument must be an integer.");
! 465: }
! 466: tt = KopInteger(t);
! 467: ans = oxclientMultiSelect(clients,dataready,controlready,size,tt);
! 468: /* synchronize oclients and clients. */
! 469: for (i=0; i<size; i++) {
! 470: ob0 = getoa(oclients,i);
! 471: oxClientToObject(clients[i],ob0);
! 472: putoa(oclients,i,ob0);
! 473: }
! 474: rob = newObjectArray(3);
! 475: putoa(rob,0,KpoInteger(ans));
! 476: ob1 = newObjectArray(size);
! 477: ob2 = newObjectArray(size);
! 478: for (i=0; i<size; i++) {
! 479: putoa(ob1,i,KpoInteger(dataready[i]));
! 480: putoa(ob2,i,KpoInteger(controlready[i]));
! 481: }
! 482: putoa(rob,1,ob1);
! 483: putoa(rob,2,ob2);
! 484: return(rob);
! 485: }
! 486:
! 487: struct object KoxWatch(struct object client,struct object f)
! 488: /* f is not used for now. It should be log file. */
! 489: {
! 490: int ans,k;
! 491: static oxclientp cc1 = NULL;
! 492: struct object rob;
! 493: rob.tag = Snull;
! 494: if (cc1 == NULL) {
! 495: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 496: if (cc1 == NULL) {
! 497: errorOxmisc2("KoxWatch(): no more memory.");
! 498: return(rob);
! 499: }
! 500: oxInitClient(cc1);
! 501: }
! 502:
! 503: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 504: if (cc1 == NULL) {
! 505: errorOxmisc2("KoxWatch(): the first argument must be a client object.");
! 506: return(rob);
! 507: }
! 508:
! 509: k = fp2watch(cc1->datafp2,stdout);
! 510: /* synchronize cc1 and client. */
! 511: oxClientToObject(cc1,client);
! 512:
! 513: return(KpoInteger(ans));
! 514: }
! 515:
! 516:
! 517: struct object KoxCloseClient(struct object client) {
! 518: oxclientp cc1 = NULL;
! 519: oxclient cc;
! 520: struct object rob;
! 521: rob.tag = Snull;
! 522: cc1 = &cc;
! 523: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 524: if (cc1 == NULL) {
! 525: errorOxmisc2("KoxCloseClient(): the first argument must be a client object.");
! 526: return(rob);
! 527: }
! 528:
! 529: fp2fflush(cc1->datafp2);
! 530: if (cc1->humanio) {
! 531: /* Do not close the file. */
! 532: return(KpoInteger(0));
! 533: }
! 534: switch (cc1->type) {
! 535: case CLIENT_SOCKET:
! 536: fp2fclose(cc1->datafp2);
! 537: close(cc1->controlfd);
! 538: break;
! 539: case CLIENT_FILE:
! 540: fp2fclose(cc1->datafp2);
! 541: close(cc1->controlfd);
! 542: break;
! 543: default:
! 544: errorOxmisc2("Unknown client->type\n");
! 545: break;
! 546: }
! 547: return(KpoInteger(0));
! 548:
! 549: }
! 550:
! 551:
! 552: errorOxmisc2(char *s) {
! 553: fprintf(MyErrorOut,"error in oxmisc2.c: %s\n",s);
! 554: return;
! 555: }
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 / Old