Annotation of OpenXM/src/kan96xx/plugin/Old/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: FILE *MyErrorOut = stdout;
! 10: #include "ox_kan.h"
! 11:
! 12: #define READBUFSIZE 5000
! 13:
! 14: int UseOXPacketSerial = 0;
! 15:
! 16:
! 17: int readOneByte(int fd) /* blocking */
! 18: {
! 19: static char data[1];
! 20: int size;
! 21: int ans;
! 22: int watch = 1;
! 23:
! 24: if (fd < 0) {
! 25: fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");
! 26: return(-1);
! 27: }
! 28:
! 29: if (oxSocketSelect0(fd,-1)) { /* block */
! 30: size = read(fd,data,1);
! 31: if (size == 0) {
! 32: fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. You peer may be killed.\n");
! 33: return(-1);
! 34: }
! 35: return(data[0]);
! 36: }else{
! 37: fprintf(MyErrorOut,"readOneByte: select error in block mode. Retrying.\n");
! 38: return(-1);
! 39: }
! 40: }
! 41:
! 42: int readOneByte_org(int fd) /* blocking */
! 43: {
! 44: static char data[READBUFSIZE];
! 45: static int thisFd = -1;
! 46: static int from = 0;
! 47: static int to = 0;
! 48: int size;
! 49: int ans;
! 50: int watch = 1;
! 51:
! 52: if ((thisFd == -1) && (fd >= 0)) {thisFd = fd;}
! 53: if (fd < 0) {
! 54: fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");
! 55: return(-1);
! 56: }
! 57:
! 58: if (fd != thisFd) {
! 59: fprintf(MyErrorOut,"readOneByte can be used only for one fd.\n");
! 60: fflush(NULL);
! 61: return(-1);
! 62: }
! 63: if (to > from) {
! 64: ans = data[from];
! 65: from++;
! 66: if (watch) {
! 67: printf("%2x ",ans);
! 68: fflush(stdout);
! 69: }
! 70: return(ans);
! 71: }
! 72:
! 73: while (1) {
! 74: if (oxSocketSelect0(fd,-1)) { /* block */
! 75: size = read(fd,data,READBUFSIZE-1);
! 76: if (size == 0) {
! 77: fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. You peer may be killed.\n");
! 78: return(-1);
! 79: }
! 80: from = 0;
! 81: to = size;
! 82: return(readOneByte(fd));
! 83: }else{
! 84: fprintf(MyErrorOut,"readOneByte: select error in block mode. Retrying.\n"); }
! 85: }
! 86: }
! 87:
! 88: int oxfdGetInt32(int fd)
! 89: {
! 90: char d[4];
! 91: int i;
! 92: for (i=0; i<4; i++) {
! 93: d[i] = readOneByte(fd);
! 94: }
! 95: return(ntohl(* ( (int *)d)));
! 96: }
! 97:
! 98: int oxGetInt32(ox_stream ostream)
! 99: {
! 100: char d[4];
! 101: int i;
! 102: for (i=0; i<4; i++) {
! 103: d[i] = fp2fgetc(ostream);
! 104: }
! 105: return(ntohl(* ( (int *)d)));
! 106: }
! 107: int oxGetCMOInt32(ox_stream ostream)
! 108: {
! 109: int id;
! 110: id = oxGetInt32(ostream);
! 111: if (id != CMO_INT32) {
! 112: fprintf(MyErrorOut,"It is not CMO_INT32.\n");
! 113: return(0);
! 114: }
! 115: return(oxGetInt32(ostream));
! 116: }
! 117: char *oxGetCMOString(ox_stream ostream) {
! 118: int id;
! 119: int size;
! 120: char *r;
! 121: int i;
! 122: id = oxGetInt32(ostream);
! 123: if (id != CMO_STRING) {
! 124: fprintf(MyErrorOut,"It is not CMO_STRING.\n");
! 125: return(NULL);
! 126: }
! 127: size = oxGetInt32(ostream);
! 128: if (size <0) {
! 129: return(NULL);
! 130: }else{
! 131: r = (char *)mymalloc(size+1);
! 132: for (i=0; i<size; i++) {
! 133: r[i] = fp2fgetc(ostream);
! 134: }
! 135: r[size] = '\0';
! 136: return(r);
! 137: }
! 138: }
! 139:
! 140: void oxfdSendSyncBall(int fd)
! 141: {
! 142: oxfdSendOXheader(fd,OX_SYNC_BALL,SerialOX++);
! 143: /*
! 144: char data[4*2];
! 145: *((int *)&data[0]) = htonl(OX_SYNC_BALL);
! 146: write(fd,data,4);
! 147: fflush((FILE *)NULL);
! 148: */
! 149: }
! 150:
! 151: void oxSendSyncBall(ox_stream os)
! 152: {
! 153: char data[4*2];
! 154: *((int *)&data[0]) = htonl(OX_SYNC_BALL);
! 155: fp2write(os,data,4);
! 156: fp2fflush(os);
! 157: }
! 158:
! 159: int oxWaitSyncBall(ox_stream ostream)
! 160: {
! 161: int mtag;
! 162: char data[4];
! 163: int c;
! 164: data[0] = data[1] = data[2] = data[3] = 0xff;
! 165: while (1) {
! 166: /* This part should be revised so that this part understands
! 167: the cmo format.
! 168: */
! 169:
! 170: if ((c = fp2fgetc(ostream)) < 0) {
! 171: /* never use read directory. readOneByte() is buffers every thing. */
! 172: fprintf(MyErrorOut,"End of file.\n");
! 173: return(-1);
! 174: }
! 175: data[0] = data[1];
! 176: data[1] = data[2];
! 177: data[2] = data[3];
! 178: data[3] = (char)c;
! 179: mtag = ntohl(*((int *)(data)));
! 180: if (mtag == OX_SYNC_BALL) {
! 181: printf("Found the OX_SYNC_BALL. \n");
! 182: fflush(NULL);
! 183: return(mtag);
! 184: }
! 185: fprintf(stderr,"Looking for the next message tag.. %2x, mtag=%d\n",c,mtag);
! 186: /* or stdout */
! 187: fflush(NULL);
! 188: }
! 189: }
! 190:
! 191:
! 192: void oxfdSendCmoNull(int fd)
! 193: {
! 194: char data[4];
! 195: *((int *)&data[0]) = htonl(CMO_NULL);
! 196: write(fd,data,4);
! 197: fflush((FILE *)NULL);
! 198: }
! 199: void oxSendCmoNull(ox_stream os)
! 200: {
! 201: char data[4];
! 202: *((int *)&data[0]) = htonl(CMO_NULL);
! 203: fp2write(os,data,4);
! 204: fp2fflush(os);
! 205: }
! 206:
! 207: void oxSendCmoError(ox_stream os)
! 208: {
! 209: char data[4];
! 210: *((int *)&data[0]) = htonl(CMO_ERROR);
! 211: fp2write(os,data,4);
! 212: fp2fflush(os);
! 213: }
! 214:
! 215: void oxSendCmoError2(ox_stream os,char *s)
! 216: {
! 217: char data[4];
! 218: *((int *)&data[0]) = htonl(CMO_ERROR2);
! 219: fp2write(os,data,4);
! 220: fp2fflush(os);
! 221: oxSendCmoString(os,s);
! 222: }
! 223:
! 224: void oxfdSendInt32(int fd,int k)
! 225: {
! 226: char data[4];
! 227: *((int *)&data[0]) = htonl(k);
! 228: write(fd,data,4);
! 229: fflush((FILE *)NULL);
! 230: }
! 231: void oxSendInt32(ox_stream os,int k)
! 232: {
! 233: char data[4];
! 234: *((int *)&data[0]) = htonl(k);
! 235: fp2write(os,data,4);
! 236: fp2fflush(os);
! 237: }
! 238:
! 239: void oxfdSendCmoInt32(int fd,int k)
! 240: {
! 241: char data[4*2];
! 242: *((int *)&data[0]) = htonl(CMO_INT32);
! 243: *((int *)&data[4]) = htonl(k);
! 244: write(fd,data,4*2);
! 245: fflush((FILE *)NULL);
! 246: }
! 247: void oxSendCmoInt32(ox_stream os,int k)
! 248: {
! 249: char data[4*2];
! 250: *((int *)&data[0]) = htonl(CMO_INT32);
! 251: *((int *)&data[4]) = htonl(k);
! 252: fp2write(os,data,4*2);
! 253: fp2fflush(os);
! 254: }
! 255: void oxfdSendCmoString(int fd,char *s)
! 256: {
! 257: char data[4*2];
! 258: int n;
! 259: if (s == NULL) n = 0;
! 260: else {
! 261: n = strlen(s);
! 262: }
! 263: *((int *)&data[0]) = htonl(CMO_STRING);
! 264: *((int *)&data[4]) = htonl(n);
! 265: write(fd,data,4*2);
! 266: if (s != NULL) {
! 267: write(fd,s,n);
! 268: }
! 269: fflush((FILE *)NULL);
! 270: }
! 271:
! 272: void oxSendCmoString(ox_stream os,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: fp2write(os,data,4*2);
! 283: if (s != NULL) {
! 284: fp2write(os,s,n);
! 285: }
! 286: fp2fflush(os);
! 287: }
! 288:
! 289: void oxReqPushString(ox_stream os, char *s)
! 290: {
! 291: oxSendInt32(os,OX_DATA);
! 292: oxSendCmoString(os,s);
! 293: }
! 294:
! 295: void oxSendResultOfControlInt32(int fd,int i)
! 296: {
! 297: char data[4*3];
! 298: *((int *)&data[0]) = htonl(OX_DATA);
! 299: *((int *)&data[4]) = htonl(CMO_INT32);
! 300: *((int *)&data[8]) = htonl(i);
! 301: write(fd,data,4*3);
! 302: fflush((FILE *)NULL);
! 303: }
! 304:
! 305: void oxSendResultOfControl(int fd)
! 306: {
! 307: char data[4*2];
! 308: *((int *)&data[0]) = htonl(OX_DATA);
! 309: *((int *)&data[4]) = htonl(CMO_NULL);
! 310: write(fd,data,4*2);
! 311: fflush((FILE *)NULL);
! 312: }
! 313:
! 314: void oxReqMathCap(ox_stream os) {
! 315: oxSendInt32(os,OX_COMMAND);
! 316: oxSendInt32(os,SM_mathcap);
! 317: fp2fflush(os);
! 318: }
! 319: void oxReqPops(ox_stream os,int n) {
! 320: oxSendInt32(os,OX_DATA);
! 321: oxSendCmoInt32(os,n);
! 322: oxSendInt32(os,OX_COMMAND);
! 323: oxSendInt32(os,SM_pops);
! 324: fp2fflush(os);
! 325: }
! 326: void oxReqSetName(ox_stream os,char *s) {
! 327: oxSendInt32(os,OX_DATA);
! 328: oxSendCmoString(os,s);
! 329: oxSendInt32(os,OX_COMMAND);
! 330: oxSendInt32(os,SM_setName);
! 331: fp2fflush(os);
! 332: }
! 333: void oxReqEvalName(ox_stream os,char *s) {
! 334: oxSendInt32(os,OX_DATA);
! 335: oxSendCmoString(os,s);
! 336: oxSendInt32(os,OX_COMMAND);
! 337: oxSendInt32(os,SM_evalName);
! 338: fp2fflush(os);
! 339: }
! 340:
! 341: void oxReqExecuteStringByLocalParser(ox_stream os,char *s)
! 342: {
! 343: oxSendInt32(os,OX_DATA);
! 344: oxSendCmoString(os,s);
! 345: oxSendInt32(os,OX_COMMAND);
! 346: oxSendInt32(os,SM_executeStringByLocalParser);
! 347: fp2fflush(os);
! 348: }
! 349:
! 350: void oxReqExecuteFunction(ox_stream os,char *s)
! 351: {
! 352: oxSendInt32(os,OX_DATA);
! 353: oxSendCmoString(os,s);
! 354: oxSendInt32(os,OX_COMMAND);
! 355: oxSendInt32(os,SM_executeFunction);
! 356: fp2fflush(os);
! 357: }
! 358:
! 359:
! 360: void oxReqPopString(ox_stream os)
! 361: {
! 362: oxSendInt32(os,OX_COMMAND);
! 363: oxSendInt32(os,SM_popString);
! 364: fp2fflush(os);
! 365: }
! 366:
! 367:
! 368: void oxReqControlResetConnection(int fd) {
! 369: oxfdSendInt32(fd,OX_COMMAND);
! 370: oxfdSendInt32(fd,SM_control_reset_connection);
! 371: fflush(NULL);
! 372: }
! 373:
! 374: void oxReqControlKill(int fd) {
! 375: oxfdSendInt32(fd,OX_COMMAND);
! 376: oxfdSendInt32(fd,SM_control_kill);
! 377: fflush(NULL);
! 378: }
! 379:
! 380: void oxReqPopCMO(ox_stream os) {
! 381: oxSendInt32(os,OX_COMMAND);
! 382: oxSendInt32(os,SM_popCMO);
! 383: fp2fflush(os);
! 384: }
! 385:
! 386:
! 387: int oxGetResultOfControlInt32(int fd) {
! 388: int k;
! 389: k = oxfdGetInt32(fd);
! 390: if (k != OX_DATA) {
! 391: fprintf(MyErrorOut,"oxGetResultOfControlInt32: wrong header.");
! 392: return(-1);
! 393: }
! 394: k = oxfdGetInt32(fd); /* CMO_INT32 */
! 395: k = oxfdGetInt32(fd);
! 396: return(k);
! 397: }
! 398:
! 399: int oxclientMultiSelect(oxclientp clients[],int dataready[],
! 400: int controlready[], int size, int t)
! 401: {
! 402: int i, ddd;
! 403: int fd;
! 404: int humanfd = 0;
! 405: fd_set readfds;
! 406: struct timeval timeout;
! 407: extern int errno;
! 408:
! 409: /** printf("(1)"); fflush(NULL); */
! 410: FD_ZERO(&readfds);
! 411: timeout.tv_sec = 0;
! 412: timeout.tv_usec = (long) t;
! 413:
! 414: ddd = 0; fd = 0;
! 415: for (i=0; i<size; i++) {
! 416: dataready[i] = controlready[i] = 0;
! 417: }
! 418: for (i=0; i<size; i++) {
! 419: if (clients[i]->humanio) {
! 420: fd = (fd<humanfd?humanfd:fd);
! 421: FD_SET(humanfd,&readfds);
! 422: if (oxSocketSelect0(humanfd,0)) {
! 423: ddd = dataready[i] = 1; controlready[i] = 0;
! 424: }else{
! 425: dataready[i] = 0; controlready[i] = 0;
! 426: }
! 427: }else{
! 428: fd = (fd<clients[i]->controlfd?clients[i]->controlfd:fd);
! 429: FD_SET(clients[i]->controlfd,&readfds);
! 430: if (oxSocketSelect0(clients[i]->controlfd,0)) {
! 431: ddd = controlready[i] = 1;
! 432: }else{
! 433: controlready[i] = 0;
! 434: }
! 435: if (clients[i]->datafp2 != NULL) {
! 436: fd = (fd<clients[i]->datafp2->fd?clients[i]->datafp2->fd:fd);
! 437: FD_SET(clients[i]->datafp2->fd,&readfds);
! 438: if (fp2select(clients[i]->datafp2,0)) {
! 439: ddd = dataready[i] = 1;
! 440: }else{
! 441: dataready[i] = 0;
! 442: }
! 443: }else{
! 444: dataready[i] = 0;
! 445: }
! 446: }
! 447: }
! 448: if (t > 0 ) {
! 449: if (ddd) return(1);
! 450: if (select(fd+1,&readfds,(fd_set *)NULL,(fd_set *)NULL,&timeout)<0) {
! 451: fprintf(MyErrorOut,"error");
! 452: return(-1);
! 453: }
! 454: return(oxclientMultiSelect(clients, dataready, controlready,size,0));
! 455: }else if (t == 0) {
! 456: return(ddd);
! 457: }else {
! 458: /** printf("(2)"); fflush(NULL); */
! 459: if (select(fd+1,&readfds,(fd_set *)NULL,(fd_set *)NULL,(struct timeval *)NULL)<0) {
! 460: fprintf(MyErrorOut,"error");
! 461: return(-1);
! 462: }
! 463: /** printf("(3)"); fflush(NULL); */
! 464: return(oxclientMultiSelect(clients, dataready, controlready,size,0));
! 465: }
! 466: }
! 467:
! 468: int oxGetControl(oxclientp client)
! 469: /* synchronized. */
! 470: {
! 471: int ans;
! 472: ox_stream os;
! 473: switch (client->cstate) {
! 474: case 1:
! 475: ans = oxGetResultOfControlInt32(client->controlfd);
! 476: client->cstate = 0;
! 477: return(ans);
! 478: default:
! 479: fprintf(MyErrorOut,"oxGet: unknown cstate.\n");
! 480: client->cstate = -1;
! 481: return(-1);
! 482: }
! 483:
! 484: return(-1);
! 485: }
! 486:
! 487: int oxInitClient(oxclientp client)
! 488: {
! 489: client->datafp2 = NULL;
! 490: client->dataport = 0;
! 491: client->controlport = 0;
! 492: client->controlfd = 0;
! 493: client->humanio = 0;
! 494: client->dstate = 0;
! 495: client->cstate = 0;
! 496: client->id = -1;
! 497: return(0);
! 498: }
! 499:
! 500: int oxIsThereErrorClient(oxclientp client) {
! 501: if (client == NULL) return(1);
! 502: if (client->dstate == -1) return(1);
! 503: if (client->cstate == -1) return(1);
! 504: return(0);
! 505: }
! 506:
! 507: oxclientp oxCreateClient(char *sname,int portStream,int portControl)
! 508: {
! 509: static int clnum = 0;
! 510: int v = 0;
! 511: int fdControl = -1;
! 512: int fdStream = -1;
! 513: oxclientp client;
! 514: v = 1;
! 515: if (portControl != -1) {
! 516: fdControl = socketConnect(sname,portControl);
! 517: if (v) fprintf(stderr,"\nControl port %d : Connected.\n",portControl);
! 518: }
! 519: if (portStream != -1) {
! 520: sleep(1); /* wait */
! 521: fdStream = socketConnect(sname,portStream);
! 522: if (v) fprintf(stderr,"\nStream port %d : Connected.\n",portStream);
! 523: }
! 524:
! 525: if (fdStream == -1 || fdControl == -1) {
! 526: fprintf(stderr,"\nOpen error in oxCreateClient.\n");
! 527: return(NULL);
! 528: }
! 529: client = (oxclientp) mymalloc(sizeof(oxclient));
! 530: oxInitClient(client);
! 531: client->datafp2 = fp2open(fdStream);
! 532: if (client->datafp2 == NULL) {
! 533: fprintf(stderr,"oxCreateClient(): fp2open(fd) failed.\n");
! 534: return(NULL);
! 535: }
! 536: client->dataport = portStream;
! 537: client->controlport = portControl;
! 538: client->controlfd = fdControl;
! 539: client->id = clnum; clnum++;
! 540: client->type = CLIENT_SOCKET; /* socket */
! 541: return(client);
! 542: }
! 543:
! 544: oxclientp oxCreateClientFile(char *fname,char *mode,char *controlName,char *cmode)
! 545: {
! 546: static int clnum = 0x8000;
! 547: int v = 0;
! 548: int fdControl = -1;
! 549: int fdStream = -1;
! 550: oxclientp client;
! 551: v = 1;
! 552: if (strcmp(mode,"w") == 0) {
! 553: fdStream = creat(fname,S_IWRITE|S_IREAD|S_IRGRP|S_IROTH);
! 554: if (fdStream < 0) {
! 555: fprintf(stderr,"\nCreat failed for %s\n",fname); return(NULL);
! 556: }
! 557: }else if (strcmp(mode,"r")==0) {
! 558: fdStream = open(fname,O_RDONLY);
! 559: if (fdStream < 0) {
! 560: fprintf(stderr,"\nOpen failed for %s\n",fname); return(NULL);
! 561: }
! 562: }else {
! 563: fprintf(stderr,"\nThe mode %s is not supported.\n",mode); return(NULL);
! 564: }
! 565:
! 566: if (strcmp(cmode,"w") == 0) {
! 567: fdControl = creat(controlName,S_IWRITE|S_IREAD|S_IRGRP|S_IROTH);
! 568: if (fdControl < 0) {
! 569: fprintf(stderr,"\nCreat failed for %s\n",controlName); return(NULL);
! 570: }
! 571: }else if (strcmp(cmode,"r")==0) {
! 572: fdControl = open(controlName,O_RDONLY);
! 573: if (fdControl < 0) {
! 574: fprintf(stderr,"\nOpen failed for %s\n",controlName); return(NULL);
! 575: }
! 576: }else if (strcmp(cmode,"rw")==0) {
! 577: fdControl = open(controlName,O_RDWR);
! 578: if (fdControl < 0) {
! 579: fprintf(stderr,"\nOpen failed for %s\n",controlName); return(NULL);
! 580: }
! 581: }else {
! 582: fprintf(stderr,"\nThe mode %s is not supported.\n",cmode); return(NULL);
! 583: }
! 584:
! 585:
! 586: client = (oxclientp) mymalloc(sizeof(oxclient));
! 587: oxInitClient(client);
! 588: client->datafp2 = fp2open(fdStream);
! 589: if (client->datafp2 == NULL) {
! 590: fprintf(stderr,"oxCreateClientFile(): fp2open(fd) failed.\n");
! 591: return(NULL);
! 592: }
! 593: client->dataport = 0;
! 594: client->controlport = 0;
! 595: client->controlfd = fdControl;
! 596: client->id = clnum; clnum++;
! 597: client->type = CLIENT_FILE;
! 598: return(client);
! 599: }
! 600:
! 601: void oxSendOXheader_generic(int type,int fd,ox_stream ox,
! 602: int k,int serial)
! 603: {
! 604: static int ss = 0;
! 605: extern int UseOXPacketSerial;
! 606: if (serial >= 0) ss = serial;
! 607: else ss++;
! 608: if (ss < 0) ss=0;
! 609: if (type == 0) { /* fd */
! 610: oxfdSendInt32(fd,k);
! 611: if (UseOXPacketSerial) oxfdSendInt32(fd,ss);
! 612: }else {
! 613: oxSendInt32(ox,k);
! 614: if (UseOXPacketSerial) oxSendInt32(ox,ss);
! 615: }
! 616: }
! 617: void oxSendOXheader(ox_stream ostream,int k,int serial) {
! 618: oxSendOXheader_generic(1,-1,ostream,k,serial);
! 619: }
! 620: void oxfdSendOXheader(int fd,int k,int serial) {
! 621: oxSendOXheader_generic(0,fd,(ox_stream) NULL,k,serial);
! 622: }
! 623:
! 624:
! 625:
! 626:
! 627:
! 628:
! 629:
! 630:
! 631:
! 632:
! 633:
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 / Old