Annotation of OpenXM/src/kan96xx/plugin/oxmisc.c, Revision 1.1
1.1 ! maekawa 1: #include <stdio.h>
! 2: #include <sys/types.h>
! 3: #include <sys/stat.h>
! 4: #include <sys/socket.h>
! 5: #include <sys/time.h>
! 6: #include <netinet/in.h>
! 7: #include <netdb.h>
! 8: #include <fcntl.h>
! 9: #include <stdlib.h>
! 10: #include <unistd.h>
! 11: #include <signal.h>
! 12: #include <setjmp.h>
! 13: FILE *MyErrorOut = stdout;
! 14:
! 15: /* Include files to understand object */
! 16: #include "../Kan/datatype.h"
! 17: #include "../Kan/stackm.h"
! 18: #include "../Kan/extern.h"
! 19:
! 20: #include "ox_kan.h"
! 21:
! 22: #define READBUFSIZE 5000
! 23:
! 24: int OxVersion = 199909080;
! 25: int UseOXPacketSerial = 1;
! 26: int SerialOX = 1;
! 27: extern int Quiet;
! 28:
! 29: static char *OxPortFileName = ".ox.dummy";
! 30:
! 31:
! 32: int readOneByte(int fd) /* blocking */
! 33: {
! 34: static char data[1];
! 35: int size;
! 36: int ans;
! 37: int watch = 1;
! 38:
! 39: if (fd < 0) {
! 40: fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");
! 41: return(-1);
! 42: }
! 43:
! 44: if (oxSocketSelect0(fd,-1)) { /* block */
! 45: size = read(fd,data,1);
! 46: if (size == 0) {
! 47: fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. You peer may be killed.\n");
! 48: return(-1);
! 49: }
! 50: return(data[0]);
! 51: }else{
! 52: fprintf(MyErrorOut,"readOneByte: select error in block mode. Retrying.\n");
! 53: return(-1);
! 54: }
! 55: }
! 56:
! 57: int readOneByte_org(int fd) /* blocking */
! 58: {
! 59: static char data[READBUFSIZE];
! 60: static int thisFd = -1;
! 61: static int from = 0;
! 62: static int to = 0;
! 63: int size;
! 64: int ans;
! 65: int watch = 1;
! 66:
! 67: if ((thisFd == -1) && (fd >= 0)) {thisFd = fd;}
! 68: if (fd < 0) {
! 69: fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");
! 70: return(-1);
! 71: }
! 72:
! 73: if (fd != thisFd) {
! 74: fprintf(MyErrorOut,"readOneByte can be used only for one fd.\n");
! 75: fflush(NULL);
! 76: return(-1);
! 77: }
! 78: if (to > from) {
! 79: ans = data[from];
! 80: from++;
! 81: if (watch) {
! 82: printf("%2x ",ans);
! 83: fflush(stdout);
! 84: }
! 85: return(ans);
! 86: }
! 87:
! 88: while (1) {
! 89: if (oxSocketSelect0(fd,-1)) { /* block */
! 90: size = read(fd,data,READBUFSIZE-1);
! 91: if (size == 0) {
! 92: fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. You peer may be killed.\n");
! 93: return(-1);
! 94: }
! 95: from = 0;
! 96: to = size;
! 97: return(readOneByte(fd));
! 98: }else{
! 99: fprintf(MyErrorOut,"readOneByte: select error in block mode. Retrying.\n"); }
! 100: }
! 101: }
! 102:
! 103: int oxfdGetInt32(int fd)
! 104: {
! 105: char d[4];
! 106: int i;
! 107: for (i=0; i<4; i++) {
! 108: d[i] = readOneByte(fd);
! 109: }
! 110: return(ntohl(* ( (int *)d)));
! 111: }
! 112:
! 113: int oxGetInt32(ox_stream ostream)
! 114: {
! 115: char d[4];
! 116: int i;
! 117: for (i=0; i<4; i++) {
! 118: d[i] = fp2fgetc(ostream);
! 119: }
! 120: return(ntohl(* ( (int *)d)));
! 121: }
! 122: int oxGetCMOInt32(ox_stream ostream)
! 123: {
! 124: int id;
! 125: id = oxGetInt32(ostream);
! 126: if (id != CMO_INT32) {
! 127: fprintf(MyErrorOut,"It is not CMO_INT32.\n");
! 128: return(0);
! 129: }
! 130: return(oxGetInt32(ostream));
! 131: }
! 132: char *oxGetCMOString(ox_stream ostream) {
! 133: int id;
! 134: int size;
! 135: char *r;
! 136: int i;
! 137: id = oxGetInt32(ostream);
! 138: if (id != CMO_STRING) {
! 139: fprintf(MyErrorOut,"It is not CMO_STRING.\n");
! 140: return(NULL);
! 141: }
! 142: size = oxGetInt32(ostream);
! 143: if (size <0) {
! 144: return(NULL);
! 145: }else{
! 146: r = (char *)mymalloc(size+1);
! 147: for (i=0; i<size; i++) {
! 148: r[i] = fp2fgetc(ostream);
! 149: }
! 150: r[size] = '\0';
! 151: return(r);
! 152: }
! 153: }
! 154:
! 155: void oxfdSendSyncBall(int fd)
! 156: {
! 157: oxfdSendOXheader(fd,OX_SYNC_BALL,SerialOX++);
! 158: }
! 159:
! 160: void oxSendSyncBall(ox_stream os)
! 161: {
! 162: oxSendOXheader(os,OX_SYNC_BALL,SerialOX++);
! 163: }
! 164:
! 165: int oxWaitSyncBall(ox_stream ostream)
! 166: {
! 167: int sss;
! 168: int mtag;
! 169: while ((mtag = oxGetOXheader(ostream,&sss)) != OX_SYNC_BALL) {
! 170: fprintf(stderr,"Looking for the next message tag. mtag=%d\n",mtag);
! 171: /* or stdout */
! 172: fflush(NULL);
! 173: }
! 174: }
! 175:
! 176: int oxWaitSyncBall_org(ox_stream ostream)
! 177: {
! 178: int mtag;
! 179: char data[4];
! 180: int c;
! 181: data[0] = data[1] = data[2] = data[3] = 0xff;
! 182: while (1) {
! 183: /* This part should be revised so that this part understands
! 184: the cmo format.
! 185: */
! 186:
! 187: if ((c = fp2fgetc(ostream)) < 0) {
! 188: /* never use read directory. readOneByte() is buffers every thing. */
! 189: fprintf(MyErrorOut,"End of file.\n");
! 190: return(-1);
! 191: }
! 192: data[0] = data[1];
! 193: data[1] = data[2];
! 194: data[2] = data[3];
! 195: data[3] = (char)c;
! 196: mtag = ntohl(*((int *)(data)));
! 197: if (mtag == OX_SYNC_BALL) {
! 198: printf("Found the OX_SYNC_BALL. \n");
! 199: fflush(NULL);
! 200: return(mtag);
! 201: }
! 202: fprintf(stderr,"Looking for the next message tag.. %2x, mtag=%d\n",c,mtag);
! 203: /* or stdout */
! 204: fflush(NULL);
! 205: }
! 206: }
! 207:
! 208:
! 209: void oxfdSendCmoNull(int fd)
! 210: {
! 211: char data[4];
! 212: *((int *)&data[0]) = htonl(CMO_NULL);
! 213: write(fd,data,4);
! 214: fflush((FILE *)NULL);
! 215: }
! 216: void oxSendCmoNull(ox_stream os)
! 217: {
! 218: char data[4];
! 219: *((int *)&data[0]) = htonl(CMO_NULL);
! 220: fp2write(os,data,4);
! 221: fp2fflush(os);
! 222: }
! 223:
! 224: void oxSendCmoError(ox_stream os)
! 225: {
! 226: char data[4];
! 227: *((int *)&data[0]) = htonl(CMO_ERROR);
! 228: fp2write(os,data,4);
! 229: fp2fflush(os);
! 230: }
! 231:
! 232: void oxSendCmoError2(ox_stream os,char *s)
! 233: {
! 234: char data[4];
! 235: *((int *)&data[0]) = htonl(CMO_ERROR2);
! 236: fp2write(os,data,4);
! 237: fp2fflush(os);
! 238: oxSendCmoString(os,s);
! 239: }
! 240:
! 241: void oxfdSendInt32(int fd,int k)
! 242: {
! 243: char data[4];
! 244: *((int *)&data[0]) = htonl(k);
! 245: write(fd,data,4);
! 246: fflush((FILE *)NULL);
! 247: }
! 248: void oxSendInt32(ox_stream os,int k)
! 249: {
! 250: char data[4];
! 251: *((int *)&data[0]) = htonl(k);
! 252: fp2write(os,data,4);
! 253: fp2fflush(os);
! 254: }
! 255:
! 256: void oxfdSendCmoInt32(int fd,int k)
! 257: {
! 258: char data[4*2];
! 259: *((int *)&data[0]) = htonl(CMO_INT32);
! 260: *((int *)&data[4]) = htonl(k);
! 261: write(fd,data,4*2);
! 262: fflush((FILE *)NULL);
! 263: }
! 264: void oxSendCmoInt32(ox_stream os,int k)
! 265: {
! 266: char data[4*2];
! 267: *((int *)&data[0]) = htonl(CMO_INT32);
! 268: *((int *)&data[4]) = htonl(k);
! 269: fp2write(os,data,4*2);
! 270: fp2fflush(os);
! 271: }
! 272: void oxfdSendCmoString(int fd,char *s)
! 273: {
! 274: char data[4*2];
! 275: int n;
! 276: if (s == NULL) n = 0;
! 277: else {
! 278: n = strlen(s);
! 279: }
! 280: *((int *)&data[0]) = htonl(CMO_STRING);
! 281: *((int *)&data[4]) = htonl(n);
! 282: write(fd,data,4*2);
! 283: if (s != NULL) {
! 284: write(fd,s,n);
! 285: }
! 286: fflush((FILE *)NULL);
! 287: }
! 288:
! 289: void oxSendCmoString(ox_stream os,char *s)
! 290: {
! 291: char data[4*2];
! 292: int n;
! 293: if (s == NULL) n = 0;
! 294: else {
! 295: n = strlen(s);
! 296: }
! 297: *((int *)&data[0]) = htonl(CMO_STRING);
! 298: *((int *)&data[4]) = htonl(n);
! 299: fp2write(os,data,4*2);
! 300: if (s != NULL) {
! 301: fp2write(os,s,n);
! 302: }
! 303: fp2fflush(os);
! 304: }
! 305:
! 306:
! 307:
! 308: void oxReqPushString(ox_stream os, char *s)
! 309: {
! 310: oxSendOXheader(os,OX_DATA,SerialOX++);
! 311: oxSendCmoString(os,s);
! 312: }
! 313:
! 314: void oxSendResultOfControlInt32(int fd,int i)
! 315: {
! 316: char data[4*2];
! 317: oxfdSendOXheader(fd,OX_DATA,SerialOX++);
! 318: *((int *)&data[0]) = htonl(CMO_INT32);
! 319: *((int *)&data[4]) = htonl(i);
! 320: write(fd,data,4*2);
! 321: fflush((FILE *)NULL);
! 322: }
! 323:
! 324: void oxSendResultOfControl(int fd)
! 325: {
! 326: char data[4*1];
! 327: oxfdSendOXheader(fd,OX_DATA,SerialOX++);
! 328: *((int *)&data[0]) = htonl(CMO_NULL);
! 329: write(fd,data,4*1);
! 330: fflush((FILE *)NULL);
! 331: }
! 332:
! 333:
! 334:
! 335: void oxSendMathCap(ox_stream os,struct mathCap *mathcap)
! 336: {
! 337: int i,n,infosize;
! 338: struct object mathinfo;
! 339: /* printf("ox sending mathcap\n"); fflush(stdout); */
! 340: mathinfo = *((struct object *)(mathcap->infop));
! 341: infosize = getoaSize(mathinfo);
! 342:
! 343: oxSendInt32(os,CMO_MATHCAP);
! 344:
! 345: oxSendInt32(os,CMO_LIST);
! 346: oxSendInt32(os,3);
! 347:
! 348: /* [0] */
! 349: oxSendInt32(os,CMO_LIST);
! 350: oxSendInt32(os,infosize);
! 351: oxSendCmoInt32(os,KopInteger(getoa(mathinfo,0)));
! 352: for (i=1; i<infosize; i++) {
! 353: oxSendCmoString(os,KopString(getoa(mathinfo,i)));
! 354: }
! 355:
! 356: /* [1] */
! 357: oxSendInt32(os,CMO_LIST);
! 358: oxSendInt32(os,mathcap->smSize);
! 359: n = mathcap->smSize;
! 360: for (i=0; i<n; i++) {
! 361: oxSendCmoInt32(os,(mathcap->sm)[i]);
! 362: }
! 363:
! 364: /* [2] */
! 365: oxSendInt32(os,CMO_LIST);
! 366: oxSendInt32(os,2);
! 367:
! 368: /* first element */
! 369: oxSendInt32(os,CMO_LIST);
! 370: oxSendInt32(os,mathcap->oxSize);
! 371: n = mathcap->oxSize;
! 372: for (i=0; i<n; i++) {
! 373: oxSendCmoInt32(os,(mathcap->ox)[i]);
! 374: }
! 375: /* second element */
! 376: oxSendInt32(os,CMO_LIST);
! 377: oxSendInt32(os,mathcap->n);
! 378: n = mathcap->n;
! 379: for (i=0; i<n; i++) {
! 380: oxSendCmoInt32(os,(mathcap->cmo)[i]);
! 381: /* printf("i=%d %d, ",i,(mathcap->cmo)[i]); */
! 382: }
! 383: /* printf("\n"); fflush(stdout); */
! 384: }
! 385:
! 386: void oxReqMathCap(ox_stream os) {
! 387: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 388: oxSendInt32(os,SM_mathcap);
! 389: fp2fflush(os);
! 390: }
! 391:
! 392: void oxReqSetMathCap(ox_stream os,struct mathCap *mathcap) {
! 393: oxSendOXheader(os,OX_DATA,SerialOX++);
! 394: oxSendMathCap(os,mathcap);
! 395: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 396: oxSendInt32(os,SM_setMathCap);
! 397: fp2fflush(os);
! 398: }
! 399: void oxReqPops(ox_stream os,int n) {
! 400: oxSendOXheader(os,OX_DATA,SerialOX++);
! 401: oxSendCmoInt32(os,n);
! 402: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 403: oxSendInt32(os,SM_pops);
! 404: fp2fflush(os);
! 405: }
! 406: void oxReqSetName(ox_stream os,char *s) {
! 407: oxSendOXheader(os,OX_DATA,SerialOX++);
! 408: oxSendCmoString(os,s);
! 409: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 410: oxSendInt32(os,SM_setName);
! 411: fp2fflush(os);
! 412: }
! 413: void oxReqEvalName(ox_stream os,char *s) {
! 414: oxSendOXheader(os,OX_DATA,SerialOX++);
! 415: oxSendCmoString(os,s);
! 416: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 417: oxSendInt32(os,SM_evalName);
! 418: fp2fflush(os);
! 419: }
! 420:
! 421: void oxReqExecuteStringByLocalParser(ox_stream os,char *s)
! 422: {
! 423: oxSendOXheader(os,OX_DATA,SerialOX++);
! 424: oxSendCmoString(os,s);
! 425: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 426: oxSendInt32(os,SM_executeStringByLocalParser);
! 427: fp2fflush(os);
! 428: }
! 429:
! 430: void oxReqExecuteFunction(ox_stream os,char *s)
! 431: {
! 432: oxSendOXheader(os,OX_DATA,SerialOX++);
! 433: oxSendCmoString(os,s);
! 434: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 435: oxSendInt32(os,SM_executeFunction);
! 436: fp2fflush(os);
! 437: }
! 438:
! 439:
! 440: void oxReqPopString(ox_stream os)
! 441: {
! 442: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 443: oxSendInt32(os,SM_popString);
! 444: fp2fflush(os);
! 445: }
! 446:
! 447: void oxReqSingleOperand(ox_stream os,int smtag)
! 448: {
! 449: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 450: oxSendInt32(os,smtag);
! 451: fp2fflush(os);
! 452: }
! 453:
! 454:
! 455: void oxReqControlResetConnection(int fd) {
! 456: oxfdSendOXheader(fd,OX_COMMAND,SerialOX++);
! 457: oxfdSendInt32(fd,SM_control_reset_connection);
! 458: fflush(NULL);
! 459: }
! 460:
! 461: void oxReqControlKill(int fd) {
! 462: oxfdSendOXheader(fd,OX_COMMAND,SerialOX++);
! 463: oxfdSendInt32(fd,SM_control_kill);
! 464: fflush(NULL);
! 465: }
! 466:
! 467: void oxReqPopCMO(ox_stream os) {
! 468: oxSendOXheader(os,OX_COMMAND,SerialOX++);
! 469: oxSendInt32(os,SM_popCMO);
! 470: fp2fflush(os);
! 471: }
! 472:
! 473:
! 474: int oxGetResultOfControlInt32(int fd) {
! 475: int k; int sss;
! 476: k = oxfdGetOXheader(fd,&sss);
! 477: if (k != OX_DATA) {
! 478: fprintf(MyErrorOut,"oxGetResultOfControlInt32: wrong header.");
! 479: return(-1);
! 480: }
! 481: k = oxfdGetInt32(fd); /* CMO_INT32 */
! 482: k = oxfdGetInt32(fd);
! 483: return(k);
! 484: }
! 485:
! 486: int oxclientMultiSelect(oxclientp clients[],int dataready[],
! 487: int controlready[], int size, int t)
! 488: {
! 489: int i, ddd;
! 490: int fd;
! 491: int humanfd = 0;
! 492: fd_set readfds;
! 493: struct timeval timeout;
! 494: extern int errno;
! 495:
! 496: /** printf("(1)"); fflush(NULL); */
! 497: FD_ZERO(&readfds);
! 498: timeout.tv_sec = 0;
! 499: timeout.tv_usec = (long) t;
! 500:
! 501: ddd = 0; fd = 0;
! 502: for (i=0; i<size; i++) {
! 503: dataready[i] = controlready[i] = 0;
! 504: }
! 505: for (i=0; i<size; i++) {
! 506: if (clients[i]->humanio) {
! 507: fd = (fd<humanfd?humanfd:fd);
! 508: FD_SET(humanfd,&readfds);
! 509: if (oxSocketSelect0(humanfd,0)) {
! 510: ddd = dataready[i] = 1; controlready[i] = 0;
! 511: }else{
! 512: dataready[i] = 0; controlready[i] = 0;
! 513: }
! 514: }else{
! 515: fd = (fd<clients[i]->controlfd?clients[i]->controlfd:fd);
! 516: FD_SET(clients[i]->controlfd,&readfds);
! 517: if (oxSocketSelect0(clients[i]->controlfd,0)) {
! 518: ddd = controlready[i] = 1;
! 519: }else{
! 520: controlready[i] = 0;
! 521: }
! 522: if (clients[i]->datafp2 != NULL) {
! 523: fd = (fd<clients[i]->datafp2->fd?clients[i]->datafp2->fd:fd);
! 524: FD_SET(clients[i]->datafp2->fd,&readfds);
! 525: if (fp2select(clients[i]->datafp2,0)) {
! 526: ddd = dataready[i] = 1;
! 527: }else{
! 528: dataready[i] = 0;
! 529: }
! 530: }else{
! 531: dataready[i] = 0;
! 532: }
! 533: }
! 534: }
! 535: if (t > 0 ) {
! 536: if (ddd) return(1);
! 537: if (select(fd+1,&readfds,(fd_set *)NULL,(fd_set *)NULL,&timeout)<0) {
! 538: fprintf(MyErrorOut,"error");
! 539: return(-1);
! 540: }
! 541: return(oxclientMultiSelect(clients, dataready, controlready,size,0));
! 542: }else if (t == 0) {
! 543: return(ddd);
! 544: }else {
! 545: /** printf("(2)"); fflush(NULL); */
! 546: if (select(fd+1,&readfds,(fd_set *)NULL,(fd_set *)NULL,(struct timeval *)NULL)<0) {
! 547: fprintf(MyErrorOut,"error");
! 548: return(-1);
! 549: }
! 550: /** printf("(3)"); fflush(NULL); */
! 551: return(oxclientMultiSelect(clients, dataready, controlready,size,0));
! 552: }
! 553: }
! 554:
! 555: int oxGetControl(oxclientp client)
! 556: /* synchronized. */
! 557: {
! 558: int ans;
! 559: ox_stream os;
! 560: switch (client->cstate) {
! 561: case 1:
! 562: ans = oxGetResultOfControlInt32(client->controlfd);
! 563: client->cstate = 0;
! 564: return(ans);
! 565: default:
! 566: fprintf(MyErrorOut,"oxGet: unknown cstate.\n");
! 567: client->cstate = -1;
! 568: return(-1);
! 569: }
! 570:
! 571: return(-1);
! 572: }
! 573:
! 574: int oxInitClient(oxclientp client)
! 575: {
! 576: client->datafp2 = NULL;
! 577: client->dataport = 0;
! 578: client->controlport = 0;
! 579: client->controlfd = 0;
! 580: client->humanio = 0;
! 581: client->dstate = 0;
! 582: client->cstate = 0;
! 583: client->id = -1;
! 584: client->mathcapObjp = NULL;
! 585: client->controlByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;
! 586: client->engineByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;
! 587: return(0);
! 588: }
! 589:
! 590: int oxIsThereErrorClient(oxclientp client) {
! 591: if (client == NULL) return(1);
! 592: if (client->dstate == -1) return(1);
! 593: if (client->cstate == -1) return(1);
! 594: return(0);
! 595: }
! 596:
! 597: oxclientp oxCreateClient(char *sname,int portStream,int portControl)
! 598: /* you also need to change oxCreateClient2. */
! 599: {
! 600: static int clnum = 0;
! 601: int v = 0;
! 602: int fdControl = -1;
! 603: int fdStream = -1;
! 604: oxclientp client;
! 605: int controlByteOrder, engineByteOrder;
! 606: v = !Quiet;
! 607: if (portControl != -1) {
! 608: fdControl = socketConnect(sname,portControl);
! 609: if (v) fprintf(stderr,"\nControl port %d : Connected.\n",portControl);
! 610: }
! 611: if (portStream != -1) {
! 612: sleep(1); /* wait */
! 613: fdStream = socketConnect(sname,portStream);
! 614: if (v) fprintf(stderr,"\nStream port %d : Connected.\n",portStream);
! 615: }
! 616:
! 617: if (fdStream == -1 || fdControl == -1) {
! 618: fprintf(stderr,"\nOpen error in oxCreateClient.\n");
! 619: return(NULL);
! 620: }
! 621:
! 622: controlByteOrder = oxSetByteOrder(fdControl);
! 623: if (v) fprintf(stderr,"Byte order for control process is %s.\n",
! 624: (controlByteOrder == 0? "network byte order":
! 625: (controlByteOrder == 1? "little indican":
! 626: "big indian")));
! 627: engineByteOrder = oxSetByteOrder(fdStream);
! 628: if (v) fprintf(stderr,"Byte order for engine process is %s.\n",
! 629: (engineByteOrder == 0? "network byte order":
! 630: (engineByteOrder == 1? "little indican":
! 631: "big indian")));
! 632:
! 633: client = (oxclientp) mymalloc(sizeof(oxclient));
! 634: oxInitClient(client);
! 635: client->datafp2 = fp2open(fdStream);
! 636: if (client->datafp2 == NULL) {
! 637: fprintf(stderr,"oxCreateClient(): fp2open(fd) failed.\n");
! 638: return(NULL);
! 639: }
! 640: client->dataport = portStream;
! 641: client->controlport = portControl;
! 642: client->controlfd = fdControl;
! 643: client->id = clnum; clnum++;
! 644: client->type = CLIENT_SOCKET; /* socket */
! 645: client->engineByteOrder = engineByteOrder;
! 646: client->controlByteOrder = controlByteOrder;
! 647: return(client);
! 648: }
! 649:
! 650: oxclientp oxCreateClientFile(char *fname,char *mode,char *controlName,char *cmode)
! 651: {
! 652: static int clnum = 0x8000;
! 653: int v = 0;
! 654: int fdControl = -1;
! 655: int fdStream = -1;
! 656: oxclientp client;
! 657: v = 1;
! 658: if (strcmp(mode,"w") == 0) {
! 659: fdStream = creat(fname,S_IWRITE|S_IREAD|S_IRGRP|S_IROTH);
! 660: if (fdStream < 0) {
! 661: fprintf(stderr,"\nCreat failed for %s\n",fname); return(NULL);
! 662: }
! 663: }else if (strcmp(mode,"r")==0) {
! 664: fdStream = open(fname,O_RDONLY);
! 665: if (fdStream < 0) {
! 666: fprintf(stderr,"\nOpen failed for %s\n",fname); return(NULL);
! 667: }
! 668: }else {
! 669: fprintf(stderr,"\nThe mode %s is not supported.\n",mode); return(NULL);
! 670: }
! 671:
! 672: if (strcmp(cmode,"w") == 0) {
! 673: fdControl = creat(controlName,S_IWRITE|S_IREAD|S_IRGRP|S_IROTH);
! 674: if (fdControl < 0) {
! 675: fprintf(stderr,"\nCreat failed for %s\n",controlName); return(NULL);
! 676: }
! 677: }else if (strcmp(cmode,"r")==0) {
! 678: fdControl = open(controlName,O_RDONLY);
! 679: if (fdControl < 0) {
! 680: fprintf(stderr,"\nOpen failed for %s\n",controlName); return(NULL);
! 681: }
! 682: }else if (strcmp(cmode,"rw")==0) {
! 683: fdControl = open(controlName,O_RDWR);
! 684: if (fdControl < 0) {
! 685: fprintf(stderr,"\nOpen failed for %s\n",controlName); return(NULL);
! 686: }
! 687: }else {
! 688: fprintf(stderr,"\nThe mode %s is not supported.\n",cmode); return(NULL);
! 689: }
! 690:
! 691:
! 692: client = (oxclientp) mymalloc(sizeof(oxclient));
! 693: oxInitClient(client);
! 694: client->datafp2 = fp2open(fdStream);
! 695: if (client->datafp2 == NULL) {
! 696: fprintf(stderr,"oxCreateClientFile(): fp2open(fd) failed.\n");
! 697: return(NULL);
! 698: }
! 699: client->dataport = 0;
! 700: client->controlport = 0;
! 701: client->controlfd = fdControl;
! 702: client->id = clnum; clnum++;
! 703: client->type = CLIENT_FILE;
! 704: client->engineByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;
! 705: client->controlByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;
! 706: return(client);
! 707: }
! 708:
! 709: void oxSendOXheader_generic(int type,int fd,ox_stream ox,
! 710: int k,int serial)
! 711: {
! 712: static int ss = 0;
! 713: extern int UseOXPacketSerial;
! 714: if (serial >= 0) ss = serial;
! 715: else ss++;
! 716: if (ss < 0) ss=0;
! 717: if (type == 0) { /* fd */
! 718: oxfdSendInt32(fd,k);
! 719: if (UseOXPacketSerial) oxfdSendInt32(fd,ss);
! 720: }else {
! 721: oxSendInt32(ox,k);
! 722: if (UseOXPacketSerial) oxSendInt32(ox,ss);
! 723: }
! 724: }
! 725: void oxSendOXheader(ox_stream ostream,int k,int serial) {
! 726: oxSendOXheader_generic(1,-1,ostream,k,serial);
! 727: }
! 728: void oxfdSendOXheader(int fd,int k,int serial) {
! 729: oxSendOXheader_generic(0,fd,(ox_stream) NULL,k,serial);
! 730: }
! 731:
! 732: int oxfdGetOXheader(int fd,int *sss)
! 733: {
! 734: char d[4];
! 735: int i;
! 736: int m;
! 737:
! 738: for (i=0; i<4; i++) {
! 739: d[i] = readOneByte(fd);
! 740: }
! 741: m = ntohl(* ( (int *)d));
! 742: *sss = -1;
! 743: if (UseOXPacketSerial) {
! 744: for (i=0; i<4; i++) {
! 745: d[i] = readOneByte(fd);
! 746: }
! 747: *sss = ntohl(* ( (int *)d));
! 748: }
! 749: return(m);
! 750: }
! 751:
! 752: int oxGetOXheader(ox_stream ostream,int *sss)
! 753: {
! 754: char d[4];
! 755: int m;
! 756: int i;
! 757:
! 758: unlockCtrlCForOx(); /* temporary unlock */
! 759: while (fp2select(ostream,1000) == 0) ;
! 760: restoreLockCtrlCForOx();
! 761:
! 762: for (i=0; i<4; i++) {
! 763: d[i] = fp2fgetc(ostream);
! 764: }
! 765: m = ntohl(* ( (int *)d));
! 766: *sss = -1;
! 767: if (UseOXPacketSerial) {
! 768: for (i=0; i<4; i++) {
! 769: d[i] = fp2fgetc(ostream);
! 770: }
! 771: *sss = ntohl(* ( (int *)d));
! 772: }
! 773: return(m);
! 774: }
! 775:
! 776:
! 777: oxWritePortFile(int func,int port,char *fname) {
! 778: char name[1024];
! 779: FILE *fp;
! 780: strcpy(name,fname);
! 781: if (func == 0) {
! 782: strcat(name,".control");
! 783: fp = fopen(name,"w");
! 784: fprintf(fp,"%05d\n",port);
! 785: fclose(fp);
! 786: }else {
! 787: strcat(name,".data");
! 788: fp = fopen(name,"w");
! 789: fprintf(fp,"%05d\n",port);
! 790: fclose(fp);
! 791: }
! 792: }
! 793: oxReadPortFile(int func,char *fname) {
! 794: int port = 0;
! 795: char name[1024];
! 796: FILE *fp;
! 797: strcpy(name,fname);
! 798: if (func == 0) {
! 799: strcat(name,".control");
! 800: fp = fopen(name,"r");
! 801: fscanf(fp,"%d",&port);
! 802: fclose(fp);
! 803: }else {
! 804: strcat(name,".data");
! 805: fp = fopen(name,"r");
! 806: fscanf(fp,"%d",&port);
! 807: fclose(fp);
! 808: }
! 809: return(port);
! 810: }
! 811: char *oxGenPortFile(void) {
! 812: char *fname;
! 813: time_t tt;
! 814: char sstime[512];
! 815:
! 816: fname = (char *)malloc(1024*sizeof(char));
! 817: strcpy(fname,getenv("HOME"));
! 818: strcat(fname,"/.ox.");
! 819: tt = time(NULL);
! 820: sprintf(sstime,"%ld",(long) tt);
! 821: strcat(fname,sstime);
! 822: if (fname[strlen(fname)-1] == '\n') {
! 823: fname[strlen(fname)-1] = '\0';
! 824: }
! 825: /* fprintf(stderr,"OxPortFileName=%s\n",fname); */
! 826: OxPortFileName = fname;
! 827: return(fname);
! 828: }
! 829: int oxRemovePortFile(void) {
! 830: char fname[1024];
! 831: FILE *fp;
! 832: strcpy(fname,OxPortFileName);
! 833: strcat(fname,".control");
! 834: if ((fp=fopen(fname,"r")) == NULL) {
! 835: }{
! 836: fclose(fp);
! 837: if (unlink(fname)) {
! 838: fprintf(MyErrorOut,"fail unlink.\n");
! 839: }
! 840:
! 841: }
! 842: strcpy(fname,OxPortFileName);
! 843: strcat(fname,".data");
! 844: if ((fp=fopen(fname,"r")) == NULL) {
! 845: }{
! 846: fclose(fp);
! 847: if (unlink(fname)) {
! 848: fprintf(MyErrorOut,"fail unlink.\n");
! 849: }
! 850: }
! 851: }
! 852:
! 853: char *oxGenPass(void) {
! 854: int seed;
! 855: long p;
! 856: char *s;
! 857: seed = (int) time(NULL);
! 858: srandom((unsigned int) seed);
! 859: p = random();
! 860: s = (char *)malloc(128*sizeof(char));
! 861: sprintf(s,"%ld",p);
! 862: return(s);
! 863: }
! 864:
! 865:
! 866: static void cancelConnection() {
! 867: extern jmp_buf MyEnv_oxmisc;
! 868: signal(SIGALRM,SIG_IGN);
! 869: fprintf(stderr,"Time out in TCP/IP connection.\n");
! 870: longjmp(MyEnv_oxmisc,1);
! 871: }
! 872:
! 873: oxclientp oxCreateClient2(int fdstream,int portStream,
! 874: int fdcontrol,int portControl,int ipmask,char *pass)
! 875: {
! 876: static int clnum = 0;
! 877: int v = 0;
! 878: int fdControl = -1;
! 879: int fdStream = -1;
! 880: int m;
! 881:
! 882: char *s;
! 883: oxclientp client;
! 884: extern jmp_buf MyEnv_oxmisc ;
! 885: int controlByteOrder, engineByteOrder;
! 886:
! 887: v = !Quiet;
! 888: if (setjmp(MyEnv_oxmisc)) {
! 889: return(NULL);
! 890: }else{
! 891: }
! 892: alarm((unsigned int) 10); /* setup timeout. */
! 893: signal(SIGALRM,cancelConnection);
! 894:
! 895: switch(ipmask) {
! 896: case 0:/* only local */
! 897: fdControl = socketAcceptLocal(fdcontrol);
! 898: fdStream = socketAcceptLocal(fdstream);
! 899: break;
! 900: default:/* any */
! 901: fdControl = socketAccept(fdcontrol);
! 902: fdStream = socketAccept(fdstream);
! 903: break;
! 904: }
! 905: if (v) fprintf(stderr,"\nControl port %d : Connected.\n",portControl);
! 906: if (v) fprintf(stderr,"\nStream port %d : Connected.\n",portStream);
! 907:
! 908: if (fdStream == -1 || fdControl == -1) {
! 909: fprintf(stderr,"\nOpen error in oxCreateClient.\n");
! 910: return(NULL);
! 911: }
! 912:
! 913: /* Authentification by password. */
! 914: m = strlen(pass);
! 915: s = (char *)mymalloc(sizeof(char)*(m+1));
! 916: read(fdControl,s,m); s[m] = '\0';
! 917: if (strcmp(s,pass) != 0) {
! 918: fprintf(stderr,"oxCreateClient2(): password authentification failed for control channel.\n");
! 919: close(fdControl);
! 920: return(NULL);
! 921: }
! 922: read(fdStream,s,m); s[m] = '\0';
! 923: if (strcmp(s,pass) != 0) {
! 924: fprintf(stderr,"oxCreateClient2(): password authentification failed for data channel.\n");
! 925: close(fdStream);
! 926: return(NULL);
! 927: }
! 928: signal(SIGALRM,SIG_IGN);
! 929:
! 930: controlByteOrder = oxSetByteOrder(fdControl);
! 931: if (v) fprintf(stderr,"Byte order for control process is %s.\n",
! 932: (controlByteOrder == 0? "network byte order":
! 933: (controlByteOrder == 1? "little indican":
! 934: "big indian")));
! 935: engineByteOrder = oxSetByteOrder(fdStream);
! 936: if (v) fprintf(stderr,"Byte order for engine process is %s.\n",
! 937: (engineByteOrder == 0? "network byte order":
! 938: (engineByteOrder == 1? "little indican":
! 939: "big indian")));
! 940:
! 941:
! 942: client = (oxclientp) mymalloc(sizeof(oxclient));
! 943: oxInitClient(client);
! 944: client->datafp2 = fp2open(fdStream);
! 945: if (client->datafp2 == NULL) {
! 946: fprintf(stderr,"oxCreateClient2(): fp2open(fd) failed.\n");
! 947: return(NULL);
! 948: }
! 949: client->dataport = portStream;
! 950: client->controlport = portControl;
! 951: client->controlfd = fdControl;
! 952: client->id = clnum; clnum++;
! 953: client->type = CLIENT_SOCKET; /* socket */
! 954: client->engineByteOrder = engineByteOrder;
! 955: client->controlByteOrder = controlByteOrder;
! 956: return(client);
! 957: }
! 958:
! 959: int oxSetByteOrder(int fd) {
! 960: char data[1];
! 961: int peertype;
! 962: /* It is for client. read and next write. */
! 963: /* oxSocketSelect0(fd,10); wait. */
! 964: read(fd,data,1);
! 965: peertype = (unsigned char) data[0];
! 966:
! 967: /* We support only Network byte order */
! 968: data[0] = OX_BYTE_NETWORK_BYTE_ORDER;
! 969: write(fd,data,1);
! 970:
! 971: return(OX_BYTE_NETWORK_BYTE_ORDER);
! 972: }
! 973:
! 974: int oxTellMyByteOrder(int fd) {
! 975: char data[1];
! 976: int peertype;
! 977: /* It is for server. read and next write. */
! 978:
! 979: /* We support only Network byte order */
! 980: data[0] = OX_BYTE_NETWORK_BYTE_ORDER;
! 981: write(fd,data,1);
! 982: fsync(fd); /* returns 0 if normal. Does it work for socket? */
! 983:
! 984: read(fd,data,1);
! 985:
! 986: return(OX_BYTE_NETWORK_BYTE_ORDER);
! 987: }
! 988:
! 989:
! 990:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to oxmisc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / plugin