[BACK]Return to oxmisc.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / plugin

Diff for /OpenXM/src/kan96xx/plugin/oxmisc.c between version 1.1.1.1 and 1.32

version 1.1.1.1, 1999/10/08 02:12:05 version 1.32, 2020/10/06 11:33:47
Line 1 
Line 1 
   /*  $OpenXM: OpenXM/src/kan96xx/plugin/oxmisc.c,v 1.31 2016/08/29 01:15:01 takayama Exp $ */
 #include <stdio.h>  #include <stdio.h>
   #include <string.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <sys/socket.h>  #include <sys/socket.h>
Line 10 
Line 12 
 #include <unistd.h>  #include <unistd.h>
 #include <signal.h>  #include <signal.h>
 #include <setjmp.h>  #include <setjmp.h>
 FILE *MyErrorOut = stdout;  #include <errno.h>
   #include <time.h>
   #define SET_MYERROROUT { if (MyErrorOut == NULL) MyErrorOut=stdout; }
   /* It is also defined in oxmisc2.c */
   FILE *MyErrorOut = NULL;
   
 /* Include files to understand object */  /* Include files to understand object */
 #include "../Kan/datatype.h"  #include "../Kan/datatype.h"
Line 18  FILE *MyErrorOut = stdout;
Line 24  FILE *MyErrorOut = stdout;
 #include "../Kan/extern.h"  #include "../Kan/extern.h"
   
 #include "ox_kan.h"  #include "ox_kan.h"
   #include "mysig.h"
   
   void restoreLockCtrlCForOx(); // defined in Kan/stackmachine.c
   
 #define READBUFSIZE 5000  #define READBUFSIZE 5000
   
 int OxVersion = 199909080;  int OxVersion = 200012030;
 int UseOXPacketSerial = 1;  int UseOXPacketSerial = 1;
 int SerialOX = 1;  int SerialOX = 1;
 extern int Quiet;  extern int Quiet;
Line 36  int readOneByte(int fd)   /* blocking */
Line 45  int readOneByte(int fd)   /* blocking */
   int ans;    int ans;
   int watch = 1;    int watch = 1;
   
     SET_MYERROROUT;
   if (fd < 0) {    if (fd < 0) {
     fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");      fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");
     return(-1);      return(-1);
Line 44  int readOneByte(int fd)   /* blocking */
Line 54  int readOneByte(int fd)   /* blocking */
   if (oxSocketSelect0(fd,-1)) { /* block */    if (oxSocketSelect0(fd,-1)) { /* block */
     size = read(fd,data,1);      size = read(fd,data,1);
     if (size == 0) {      if (size == 0) {
       fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. You peer may be killed.\n");        fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. Your peer may be killed.\n");
       return(-1);        return(-1);
     }      }
     return(data[0]);      return(data[0]);
Line 64  int readOneByte_org(int fd)   /* blocking */
Line 74  int readOneByte_org(int fd)   /* blocking */
   int ans;    int ans;
   int watch = 1;    int watch = 1;
   
     SET_MYERROROUT;
   if ((thisFd == -1) && (fd >= 0)) {thisFd = fd;}    if ((thisFd == -1) && (fd >= 0)) {thisFd = fd;}
   if (fd < 0) {    if (fd < 0) {
     fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");      fprintf(MyErrorOut,"readOneByte fd < 0 ??? .\n");
Line 89  int readOneByte_org(int fd)   /* blocking */
Line 100  int readOneByte_org(int fd)   /* blocking */
     if (oxSocketSelect0(fd,-1)) { /* block */      if (oxSocketSelect0(fd,-1)) { /* block */
       size = read(fd,data,READBUFSIZE-1);        size = read(fd,data,READBUFSIZE-1);
       if (size == 0) {        if (size == 0) {
         fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. You peer may be killed.\n");          fprintf(MyErrorOut,"oxSocketSelect0() returns 1, but there is no data. Your peer may be killed.\n");
         return(-1);          return(-1);
       }        }
       from = 0;        from = 0;
       to = size;        to = size;
Line 122  int oxGetInt32(ox_stream ostream)
Line 133  int oxGetInt32(ox_stream ostream)
 int oxGetCMOInt32(ox_stream ostream)  int oxGetCMOInt32(ox_stream ostream)
 {  {
   int id;    int id;
     SET_MYERROROUT;
   id = oxGetInt32(ostream);    id = oxGetInt32(ostream);
   if (id != CMO_INT32) {    if (id != CMO_INT32) {
     fprintf(MyErrorOut,"It is not CMO_INT32.\n");      fprintf(MyErrorOut,"It is not CMO_INT32.\n");
Line 134  char *oxGetCMOString(ox_stream ostream) {
Line 146  char *oxGetCMOString(ox_stream ostream) {
   int size;    int size;
   char *r;    char *r;
   int i;    int i;
     SET_MYERROROUT;
   id = oxGetInt32(ostream);    id = oxGetInt32(ostream);
   if (id != CMO_STRING) {    if (id != CMO_STRING) {
     fprintf(MyErrorOut,"It is not CMO_STRING.\n");      fprintf(MyErrorOut,"It is not CMO_STRING.\n");
Line 166  int oxWaitSyncBall(ox_stream ostream)
Line 179  int oxWaitSyncBall(ox_stream ostream)
 {  {
   int sss;    int sss;
   int mtag;    int mtag;
     int com;
   while ((mtag = oxGetOXheader(ostream,&sss)) != OX_SYNC_BALL) {    while ((mtag = oxGetOXheader(ostream,&sss)) != OX_SYNC_BALL) {
     fprintf(stderr,"Looking for the next message tag. mtag=%d\n",mtag);      switch (mtag) {
           /* or stdout */      case OX_COMMAND:
         fprintf(stderr,"Waiting for command body: "); fflush(NULL);
         com=oxGetInt32(ostream);
         fprintf(stderr,"%d. Done\n",com);
         break;
       default:  /* Todo, need support OX_DATA */
         fprintf(stderr,"Looking for the next message tag. Current unknown or unimplented mtag=%d\n",mtag);
         if (UseOXPacketSerial) fprintf(stderr,"Note that we expect the OX message tag with a serial number.\n");
         if (UseOXPacketSerial && (sss == OX_SYNC_BALL)) {
           /* dirty trick, it might cause a trouble. */
           fprintf(stderr,"We assume that the serial number is OX_SYNC_BALL\n");
           oxGetInt32(ostream); // discard the serial of OX_SYNC_BALL
           goto aaa ;
         }
         break;
       }
     aaa:
       /* or stdout */
     fflush(NULL);      fflush(NULL);
           if (mtag == -1) {
             fprintf(stderr,"Your peer seems to be dead.\n"); return 0;
           }
   }    }
 }  }
   
Line 178  int oxWaitSyncBall_org(ox_stream ostream)
Line 212  int oxWaitSyncBall_org(ox_stream ostream)
   int mtag;    int mtag;
   char data[4];    char data[4];
   int c;    int c;
     SET_MYERROROUT;
   data[0] = data[1] = data[2] = data[3] = 0xff;    data[0] = data[1] = data[2] = data[3] = 0xff;
   while (1) {    while (1) {
     /* This part should be revised so that this part understands      /* This part should be revised so that this part understands
        the cmo format.         the cmo format.
        */      */
   
     if ((c = fp2fgetc(ostream)) < 0) {      if ((c = fp2fgetc(ostream)) < 0) {
       /* never use read directory. readOneByte() is buffers every thing. */        /* never use read directory. readOneByte() is buffers every thing. */
Line 200  int oxWaitSyncBall_org(ox_stream ostream)
Line 235  int oxWaitSyncBall_org(ox_stream ostream)
       return(mtag);        return(mtag);
     }      }
     fprintf(stderr,"Looking for the next message tag.. %2x, mtag=%d\n",c,mtag);      fprintf(stderr,"Looking for the next message tag.. %2x, mtag=%d\n",c,mtag);
           /* or stdout */      /* or stdout */
     fflush(NULL);      fflush(NULL);
   }    }
 }  }
Line 210  void oxfdSendCmoNull(int fd)
Line 245  void oxfdSendCmoNull(int fd)
 {  {
   char data[4];    char data[4];
   *((int *)&data[0]) = htonl(CMO_NULL);    *((int *)&data[0]) = htonl(CMO_NULL);
   write(fd,data,4);    {int r; r=write(fd,data,4);}
   fflush((FILE *)NULL);    fflush((FILE *)NULL);
 }  }
 void oxSendCmoNull(ox_stream os)  void oxSendCmoNull(ox_stream os)
Line 242  void oxfdSendInt32(int fd,int k)
Line 277  void oxfdSendInt32(int fd,int k)
 {  {
   char data[4];    char data[4];
   *((int *)&data[0]) = htonl(k);    *((int *)&data[0]) = htonl(k);
   write(fd,data,4);    {int r; r=write(fd,data,4);}
   fflush((FILE *)NULL);    fflush((FILE *)NULL);
 }  }
 void oxSendInt32(ox_stream os,int k)  void oxSendInt32(ox_stream os,int k)
Line 258  void oxfdSendCmoInt32(int fd,int k)
Line 293  void oxfdSendCmoInt32(int fd,int k)
   char data[4*2];    char data[4*2];
   *((int *)&data[0]) = htonl(CMO_INT32);    *((int *)&data[0]) = htonl(CMO_INT32);
   *((int *)&data[4]) = htonl(k);    *((int *)&data[4]) = htonl(k);
   write(fd,data,4*2);    {int r; r=write(fd,data,4*2);}
   fflush((FILE *)NULL);    fflush((FILE *)NULL);
 }  }
 void oxSendCmoInt32(ox_stream os,int k)  void oxSendCmoInt32(ox_stream os,int k)
Line 279  void oxfdSendCmoString(int fd,char *s)
Line 314  void oxfdSendCmoString(int fd,char *s)
   }    }
   *((int *)&data[0]) = htonl(CMO_STRING);    *((int *)&data[0]) = htonl(CMO_STRING);
   *((int *)&data[4]) = htonl(n);    *((int *)&data[4]) = htonl(n);
   write(fd,data,4*2);    {int r; r=write(fd,data,4*2);}
   if (s != NULL) {    if (s != NULL) {
     write(fd,s,n);      {int r; r=write(fd,s,n);}
   }    }
   fflush((FILE *)NULL);    fflush((FILE *)NULL);
 }  }
Line 317  void oxSendResultOfControlInt32(int fd,int i) 
Line 352  void oxSendResultOfControlInt32(int fd,int i) 
   oxfdSendOXheader(fd,OX_DATA,SerialOX++);    oxfdSendOXheader(fd,OX_DATA,SerialOX++);
   *((int *)&data[0]) = htonl(CMO_INT32);    *((int *)&data[0]) = htonl(CMO_INT32);
   *((int *)&data[4]) = htonl(i);    *((int *)&data[4]) = htonl(i);
   write(fd,data,4*2);    {int r; r=write(fd,data,4*2);}
   fflush((FILE *)NULL);    fflush((FILE *)NULL);
 }  }
   
Line 326  void oxSendResultOfControl(int fd) 
Line 361  void oxSendResultOfControl(int fd) 
   char data[4*1];    char data[4*1];
   oxfdSendOXheader(fd,OX_DATA,SerialOX++);    oxfdSendOXheader(fd,OX_DATA,SerialOX++);
   *((int *)&data[0]) = htonl(CMO_NULL);    *((int *)&data[0]) = htonl(CMO_NULL);
   write(fd,data,4*1);    {int r; r=write(fd,data,4*1);}
   fflush((FILE *)NULL);    fflush((FILE *)NULL);
 }  }
   
Line 334  void oxSendResultOfControl(int fd) 
Line 369  void oxSendResultOfControl(int fd) 
   
 void oxSendMathCap(ox_stream os,struct mathCap *mathcap)  void oxSendMathCap(ox_stream os,struct mathCap *mathcap)
 {  {
   int i,n,infosize;    int i,n,infosize,ncmo;
   struct object mathinfo;    struct object mathinfo = OINIT;
   /* printf("ox sending mathcap\n"); fflush(stdout); */    /* printf("ox sending mathcap\n"); fflush(stdout); */
   mathinfo = *((struct object *)(mathcap->infop));    mathinfo = *((struct object *)(mathcap->infop));
   infosize = getoaSize(mathinfo);    infosize = getoaSize(mathinfo);
Line 363  void oxSendMathCap(ox_stream os,struct mathCap *mathca
Line 398  void oxSendMathCap(ox_stream os,struct mathCap *mathca
   
   /* [2] */    /* [2] */
   oxSendInt32(os,CMO_LIST);    oxSendInt32(os,CMO_LIST);
   oxSendInt32(os,2);    n = mathcap->oxSize;
     oxSendInt32(os,n);
   
   /* first element */  
   oxSendInt32(os,CMO_LIST);    oxSendInt32(os,CMO_LIST);
   oxSendInt32(os,mathcap->oxSize);    oxSendInt32(os,2);
   n = mathcap->oxSize;  
   for (i=0; i<n; i++) {    for (i=0; i<n; i++) {
       /* OX_DATA_xxx */
     oxSendCmoInt32(os,(mathcap->ox)[i]);      oxSendCmoInt32(os,(mathcap->ox)[i]);
       /* OX_DATA_xxx tags. In case of CMO, it is CMO tags. */
       oxSendInt32(os,CMO_LIST);
       oxSendInt32(os,mathcap->n);
       ncmo = mathcap->n;
       for (i=0; i<ncmo; i++) {
         oxSendCmoInt32(os,(mathcap->cmo)[i]);
         /* printf("i=%d %d, ",i,(mathcap->cmo)[i]); */
       }
   }    }
   /* second element */  
   oxSendInt32(os,CMO_LIST);  
   oxSendInt32(os,mathcap->n);  
   n = mathcap->n;  
   for (i=0; i<n; i++) {  
     oxSendCmoInt32(os,(mathcap->cmo)[i]);  
     /* printf("i=%d %d, ",i,(mathcap->cmo)[i]); */  
   }  
   /* printf("\n"); fflush(stdout); */    /* printf("\n"); fflush(stdout); */
 }  }
   
Line 436  void oxReqExecuteFunction(ox_stream os,char *s)
Line 471  void oxReqExecuteFunction(ox_stream os,char *s)
   fp2fflush(os);    fp2fflush(os);
 }  }
   
   void oxReqExecuteFunctionWithOptionalArgument(ox_stream os,char *s)
   {
     oxSendOXheader(os,OX_DATA,SerialOX++);
     oxSendCmoString(os,s);
     oxSendOXheader(os,OX_COMMAND,SerialOX++);
     oxSendInt32(os,SM_executeFunctionWithOptionalArgument);
     fp2fflush(os);
   }
   
   
 void oxReqPopString(ox_stream os)  void oxReqPopString(ox_stream os)
 {  {
   oxSendOXheader(os,OX_COMMAND,SerialOX++);    oxSendOXheader(os,OX_COMMAND,SerialOX++);
Line 473  void oxReqPopCMO(ox_stream os) {
Line 517  void oxReqPopCMO(ox_stream os) {
   
 int oxGetResultOfControlInt32(int fd) {  int oxGetResultOfControlInt32(int fd) {
   int k; int sss;    int k; int sss;
     SET_MYERROROUT;
   k = oxfdGetOXheader(fd,&sss);    k = oxfdGetOXheader(fd,&sss);
   if (k != OX_DATA) {    if (k != OX_DATA) {
     fprintf(MyErrorOut,"oxGetResultOfControlInt32: wrong header.");      fprintf(MyErrorOut,"oxGetResultOfControlInt32: wrong header.");
Line 484  int oxGetResultOfControlInt32(int fd) {
Line 529  int oxGetResultOfControlInt32(int fd) {
 }  }
   
 int oxclientMultiSelect(oxclientp clients[],int dataready[],  int oxclientMultiSelect(oxclientp clients[],int dataready[],
                         int controlready[], int size, int t)                          int controlready[], int size, int t)
 {  {
   int i, ddd;    int i, ddd;
   int fd;    int fd;
   int humanfd = 0;    int humanfd = 0;
   fd_set readfds;    fd_set readfds;
   struct timeval timeout;    struct timeval timeout;
   extern int errno;  
   
     SET_MYERROROUT;
   /** printf("(1)"); fflush(NULL); */    /** printf("(1)"); fflush(NULL); */
   FD_ZERO(&readfds);    FD_ZERO(&readfds);
   timeout.tv_sec = 0;    timeout.tv_sec = 0;
Line 507  int oxclientMultiSelect(oxclientp clients[],int datare
Line 552  int oxclientMultiSelect(oxclientp clients[],int datare
       fd = (fd<humanfd?humanfd:fd);        fd = (fd<humanfd?humanfd:fd);
       FD_SET(humanfd,&readfds);        FD_SET(humanfd,&readfds);
       if (oxSocketSelect0(humanfd,0)) {        if (oxSocketSelect0(humanfd,0)) {
         ddd = dataready[i] = 1; controlready[i] = 0;          ddd = dataready[i] = 1; controlready[i] = 0;
       }else{        }else{
         dataready[i] = 0; controlready[i] = 0;          dataready[i] = 0; controlready[i] = 0;
       }        }
     }else{      }else{
       fd = (fd<clients[i]->controlfd?clients[i]->controlfd:fd);        if (clients[i]->controlport < 0) { /* For RFC_101 */
       FD_SET(clients[i]->controlfd,&readfds);          controlready[i] = 0;
       if (oxSocketSelect0(clients[i]->controlfd,0)) {  
         ddd = controlready[i] = 1;  
       }else{        }else{
         controlready[i] = 0;          fd = (fd<clients[i]->controlfd?clients[i]->controlfd:fd);
           FD_SET(clients[i]->controlfd,&readfds);
           if (oxSocketSelect0(clients[i]->controlfd,0)) {
             ddd = controlready[i] = 1;
           }else{
             controlready[i] = 0;
           }
       }        }
       if (clients[i]->datafp2 != NULL) {        if (clients[i]->datafp2 != NULL) {
         fd = (fd<clients[i]->datafp2->fd?clients[i]->datafp2->fd:fd);          fd = (fd<clients[i]->datafp2->fd?clients[i]->datafp2->fd:fd);
         FD_SET(clients[i]->datafp2->fd,&readfds);          FD_SET(clients[i]->datafp2->fd,&readfds);
         if (fp2select(clients[i]->datafp2,0)) {          if (fp2select(clients[i]->datafp2,0)) {
           ddd = dataready[i] = 1;            ddd = dataready[i] = 1;
         }else{          }else{
           dataready[i] = 0;            dataready[i] = 0;
         }          }
       }else{        }else{
         dataready[i] = 0;          dataready[i] = 0;
       }        }
     }      }
   }    }
Line 553  int oxclientMultiSelect(oxclientp clients[],int datare
Line 602  int oxclientMultiSelect(oxclientp clients[],int datare
 }  }
   
 int oxGetControl(oxclientp client)  int oxGetControl(oxclientp client)
 /* synchronized. */       /* synchronized. */
 {  {
   int ans;    int ans;
   ox_stream os;    ox_stream os;
Line 584  int oxInitClient(oxclientp client)
Line 633  int oxInitClient(oxclientp client)
   client->mathcapObjp = NULL;    client->mathcapObjp = NULL;
   client->controlByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;    client->controlByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;
   client->engineByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;    client->engineByteOrder = OX_BYTE_NETWORK_BYTE_ORDER;
     client->engineID = -1;
   return(0);    return(0);
 }  }
   
Line 594  int oxIsThereErrorClient(oxclientp client) {
Line 644  int oxIsThereErrorClient(oxclientp client) {
   return(0);    return(0);
 }  }
   
 oxclientp oxCreateClient(char *sname,int portStream,int portControl)  oxclientp oxCreateClient(char *sname,int portStream,int portControl,
   /* you also need to change oxCreateClient2. */                           char *passControl, char *passData)
        /* you also need to change oxCreateClient2. */
 {  {
   static int clnum = 0;  
   int v = 0;    int v = 0;
   int fdControl = -1;    int fdControl = -1;
   int fdStream = -1;    int fdStream = -1;
Line 619  oxclientp oxCreateClient(char *sname,int portStream,in
Line 669  oxclientp oxCreateClient(char *sname,int portStream,in
     return(NULL);      return(NULL);
   }    }
   
     if (passControl != NULL) {
       if (v) fprintf(stderr,"Sending password %s for the control channel.\n",
                      passControl);
       if (write(fdControl,passControl,strlen(passControl)+1) < 0) {
         fprintf(stderr,"oxCreateClient(): failed to send passControl.\n");
         return(NULL);
       }
     }
     if (passData != NULL) {
       if (v) fprintf(stderr,"Sending password %s for the data channel.\n",
                      passData);
       if (write(fdStream,passData,strlen(passData)+1) < 0) {
         fprintf(stderr,"oxCreateClient(): failed to send passData.\n");
         return(NULL);
       }
     }
   
   controlByteOrder = oxSetByteOrder(fdControl);    controlByteOrder = oxSetByteOrder(fdControl);
   if (v) fprintf(stderr,"Byte order for control process is %s.\n",    if (v) fprintf(stderr,"Byte order for control process is %s.\n",
                  (controlByteOrder == 0? "network byte order":                   (controlByteOrder == 0? "network byte order":
                   (controlByteOrder == 1? "little indican":                    (controlByteOrder == 1? "little indican":
                    "big indian")));                     "big indian")));
   engineByteOrder = oxSetByteOrder(fdStream);    engineByteOrder = oxSetByteOrder(fdStream);
   if (v) fprintf(stderr,"Byte order for engine process is %s.\n",    if (v) fprintf(stderr,"Byte order for engine process is %s.\n",
                  (engineByteOrder == 0? "network byte order":                   (engineByteOrder == 0? "network byte order":
                   (engineByteOrder == 1? "little indican":                    (engineByteOrder == 1? "little indican":
                    "big indian")));                     "big indian")));
   
   client = (oxclientp) mymalloc(sizeof(oxclient));    client = (oxclientp) mymalloc(sizeof(oxclient));
   oxInitClient(client);    oxInitClient(client);
Line 640  oxclientp oxCreateClient(char *sname,int portStream,in
Line 707  oxclientp oxCreateClient(char *sname,int portStream,in
   client->dataport = portStream;    client->dataport = portStream;
   client->controlport = portControl;    client->controlport = portControl;
   client->controlfd = fdControl;    client->controlfd = fdControl;
   client->id = clnum; clnum++;    client->id = oxGetClientID();
   client->type = CLIENT_SOCKET; /* socket */    client->type = CLIENT_SOCKET; /* socket */
   client->engineByteOrder = engineByteOrder;    client->engineByteOrder = engineByteOrder;
   client->controlByteOrder = controlByteOrder;    client->controlByteOrder = controlByteOrder;
Line 707  oxclientp oxCreateClientFile(char *fname,char *mode,ch
Line 774  oxclientp oxCreateClientFile(char *fname,char *mode,ch
 }  }
   
 void oxSendOXheader_generic(int type,int fd,ox_stream ox,  void oxSendOXheader_generic(int type,int fd,ox_stream ox,
                             int k,int serial)                              int k,int serial)
 {  {
   static int ss = 0;    static int ss = 0;
   extern int UseOXPacketSerial;    extern int UseOXPacketSerial;
Line 774  int oxGetOXheader(ox_stream ostream,int *sss)
Line 841  int oxGetOXheader(ox_stream ostream,int *sss)
 }  }
   
   
 oxWritePortFile(int func,int port,char *fname) {  int oxWritePortFile(int func,int port,char *fname) {
   char name[1024];    char name[1024];
   FILE *fp;    FILE *fp;
   strcpy(name,fname);    strcpy(name,fname);
Line 790  oxWritePortFile(int func,int port,char *fname) {
Line 857  oxWritePortFile(int func,int port,char *fname) {
     fclose(fp);      fclose(fp);
   }    }
 }  }
 oxReadPortFile(int func,char *fname) {  int oxReadPortFile(int func,char *fname) {
   int port = 0;    int port = 0;
   char name[1024];    char name[1024];
   FILE *fp;    FILE *fp;
Line 798  oxReadPortFile(int func,char *fname) {
Line 865  oxReadPortFile(int func,char *fname) {
   if (func == 0) {    if (func == 0) {
     strcat(name,".control");      strcat(name,".control");
     fp = fopen(name,"r");      fp = fopen(name,"r");
     fscanf(fp,"%d",&port);      {int r; r=fscanf(fp,"%d",&port);}
     fclose(fp);      fclose(fp);
   }else {    }else {
     strcat(name,".data");      strcat(name,".data");
     fp = fopen(name,"r");      fp = fopen(name,"r");
     fscanf(fp,"%d",&port);      {int r; r=fscanf(fp,"%d",&port);}
     fclose(fp);      fclose(fp);
   }    }
   return(port);    return(port);
Line 829  char *oxGenPortFile(void) {
Line 896  char *oxGenPortFile(void) {
 int oxRemovePortFile(void) {  int oxRemovePortFile(void) {
   char fname[1024];    char fname[1024];
   FILE *fp;    FILE *fp;
     SET_MYERROROUT;
   strcpy(fname,OxPortFileName);    strcpy(fname,OxPortFileName);
   strcat(fname,".control");    strcat(fname,".control");
   if ((fp=fopen(fname,"r")) == NULL) {    if ((fp=fopen(fname,"r")) == NULL) {
Line 851  int oxRemovePortFile(void) {
Line 919  int oxRemovePortFile(void) {
 }  }
   
 char *oxGenPass(void) {  char *oxGenPass(void) {
   int seed;    static int seed = 0;
   long p;    long p;
   char *s;    char *s;
   seed = (int) time(NULL);    int i,n;
   srandom((unsigned int) seed);    if (seed == 0) {
   p = random();      seed = (int) time(NULL) + (int) ((long) &p);
       srandom((unsigned int) seed);
     }
   s = (char *)malloc(128*sizeof(char));    s = (char *)malloc(128*sizeof(char));
     if (s == NULL) { fprintf(stderr,"No more memory.\n"); return(s); }
     n = (((int)((long) s)) + (int) time(NULL)) % 100;
     for (i=0; i < n ; i++) random();
     p = random();
   sprintf(s,"%ld",p);    sprintf(s,"%ld",p);
   return(s);    return(s);
 }  }
   
   
 static void cancelConnection() {  static void cancelConnection() {
   #if defined(__CYGWIN__)
     extern sigjmp_buf MyEnv_oxmisc;
   #else
   extern jmp_buf MyEnv_oxmisc;    extern jmp_buf MyEnv_oxmisc;
   signal(SIGALRM,SIG_IGN);  #endif
     mysignal(SIGALRM,SIG_IGN);
   fprintf(stderr,"Time out in TCP/IP connection.\n");    fprintf(stderr,"Time out in TCP/IP connection.\n");
   longjmp(MyEnv_oxmisc,1);  #if defined(__CYGWIN__)
     MYSIGLONGJMP(MyEnv_oxmisc,1);
   #else
     MYLONGJMP(MyEnv_oxmisc,1);
   #endif
 }  }
   
 oxclientp oxCreateClient2(int fdstream,int portStream,  oxclientp oxCreateClient2(int fdstream,int portStream,
                           int fdcontrol,int portControl,int ipmask,char *pass)                            int fdcontrol,int portControl,int ipmask,
                             char *passControl, char *passData)
 {  {
   static int clnum = 0;  
   int v = 0;    int v = 0;
   int fdControl = -1;    int fdControl = -1;
   int fdStream = -1;    int fdStream = -1;
Line 881  oxclientp oxCreateClient2(int fdstream,int portStream,
Line 963  oxclientp oxCreateClient2(int fdstream,int portStream,
   
   char *s;    char *s;
   oxclientp client;    oxclientp client;
   extern jmp_buf MyEnv_oxmisc ;  #if defined(__CYGWIN__)
     extern sigjmp_buf MyEnv_oxmisc;
   #else
     extern jmp_buf MyEnv_oxmisc;
   #endif
   int controlByteOrder, engineByteOrder;    int controlByteOrder, engineByteOrder;
   
   v = !Quiet;    v = !Quiet;
   if (setjmp(MyEnv_oxmisc)) {  #if defined(__CYGWIN__)
     if (MYSIGSETJMP(MyEnv_oxmisc,1)) {
   #else
     if (MYSETJMP(MyEnv_oxmisc)) {
   #endif
     return(NULL);      return(NULL);
   }else{    }else{
   }    }
   alarm((unsigned int) 10);  /* setup timeout. */    alarm((unsigned int) 20);  /* setup timeout. */
   signal(SIGALRM,cancelConnection);    mysignal(SIGALRM,cancelConnection);
   
   switch(ipmask) {    switch(ipmask) {
   case 0:/* only local */    case 0:/* only local */
Line 906  oxclientp oxCreateClient2(int fdstream,int portStream,
Line 996  oxclientp oxCreateClient2(int fdstream,int portStream,
   if (v) fprintf(stderr,"\nStream port %d : Connected.\n",portStream);    if (v) fprintf(stderr,"\nStream port %d : Connected.\n",portStream);
   
   if (fdStream == -1 || fdControl == -1) {    if (fdStream == -1 || fdControl == -1) {
     fprintf(stderr,"\nOpen error in oxCreateClient.\n");      fprintf(stderr,"\nOpen error in oxCreateClient2.\n");
       fprintf(stderr,"fdStream=%d, fdControl=%d\n",fdStream,fdControl);
     return(NULL);      return(NULL);
   }    }
   
   /* Authentification by password. */    /* Authentication by password. */
   m = strlen(pass);    m = strlen(passControl)+strlen(passData);
   s = (char *)mymalloc(sizeof(char)*(m+1));    if (m > 0) {
   read(fdControl,s,m); s[m] = '\0';      s = (char *)mymalloc(sizeof(char)*(m+1));
   if (strcmp(s,pass) != 0) {      m = strlen(passControl); s[0] = 0;
     fprintf(stderr,"oxCreateClient2(): password authentification failed for control channel.\n");      {int r; r=read(fdControl,s,m+1);} s[m] = '\0';
     close(fdControl);      if (strcmp(s,passControl) != 0) {
     return(NULL);        fprintf(stderr,"s=%s, passControl=%s\n",s,passControl);
         fprintf(stderr,"oxCreateClient2(): password authentication failed for control channel.\n");
         close(fdControl);
         return(NULL);
       }
       m = strlen(passData); s[0] = 0;
       {int r; r=read(fdStream,s,m+1);} s[m] = '\0';
       if (strcmp(s,passData) != 0) {
         fprintf(stderr,"s=%s, passData=%s\n",s,passData);
         fprintf(stderr,"oxCreateClient2(): password authentication failed for data channel.\n");
         close(fdStream);
         return(NULL);
       }
   }    }
   read(fdStream,s,m); s[m] = '\0';    mysignal(SIGALRM,SIG_IGN);
   if (strcmp(s,pass) != 0) {  
     fprintf(stderr,"oxCreateClient2(): password authentification failed for data channel.\n");  
     close(fdStream);  
     return(NULL);  
   }  
   signal(SIGALRM,SIG_IGN);  
   
   controlByteOrder = oxSetByteOrder(fdControl);    controlByteOrder = oxSetByteOrder(fdControl);
   if (v) fprintf(stderr,"Byte order for control process is %s.\n",    if (v) fprintf(stderr,"Byte order for control process is %s.\n",
                  (controlByteOrder == 0? "network byte order":                   (controlByteOrder == 0? "network byte order":
                   (controlByteOrder == 1? "little indican":                    (controlByteOrder == 1? "little indican":
                    "big indian")));                     "big indian")));
   engineByteOrder = oxSetByteOrder(fdStream);    engineByteOrder = oxSetByteOrder(fdStream);
   if (v) fprintf(stderr,"Byte order for engine process is %s.\n",    if (v) fprintf(stderr,"Byte order for engine process is %s.\n",
                  (engineByteOrder == 0? "network byte order":                   (engineByteOrder == 0? "network byte order":
                   (engineByteOrder == 1? "little indican":                    (engineByteOrder == 1? "little indican":
                    "big indian")));                     "big indian")));
   
   
   client = (oxclientp) mymalloc(sizeof(oxclient));    client = (oxclientp) mymalloc(sizeof(oxclient));
Line 949  oxclientp oxCreateClient2(int fdstream,int portStream,
Line 1046  oxclientp oxCreateClient2(int fdstream,int portStream,
   client->dataport = portStream;    client->dataport = portStream;
   client->controlport = portControl;    client->controlport = portControl;
   client->controlfd = fdControl;    client->controlfd = fdControl;
   client->id = clnum; clnum++;    client->id = oxGetClientID();
   client->type = CLIENT_SOCKET; /* socket */    client->type = CLIENT_SOCKET; /* socket */
   client->engineByteOrder = engineByteOrder;    client->engineByteOrder = engineByteOrder;
   client->controlByteOrder = controlByteOrder;    client->controlByteOrder = controlByteOrder;
Line 961  int oxSetByteOrder(int fd) {
Line 1058  int oxSetByteOrder(int fd) {
   int peertype;    int peertype;
   /* It is for client. read and next write. */    /* It is for client. read and next write. */
   /* oxSocketSelect0(fd,10);  wait. */    /* oxSocketSelect0(fd,10);  wait. */
   read(fd,data,1);    {int r; r=read(fd,data,1);}
   peertype = (unsigned char) data[0];    peertype = (unsigned char) data[0];
   
   /* We support only Network byte order */    /* We support only Network byte order */
   data[0] = OX_BYTE_NETWORK_BYTE_ORDER;    data[0] = OX_BYTE_NETWORK_BYTE_ORDER;
   write(fd,data,1);    {int r; r=write(fd,data,1);}
   
   return(OX_BYTE_NETWORK_BYTE_ORDER);    return(OX_BYTE_NETWORK_BYTE_ORDER);
 }  }
   
 int oxTellMyByteOrder(int fd) {  int oxTellMyByteOrder(int fdOut, int fdIn) {
   char data[1];    char data[1];
   int peertype;    int peertype;
   /* It is for server. read and next write. */    /* It is for server. read and next write. */
   
   /* We support only Network byte order */    /* We support only Network byte order */
   data[0] = OX_BYTE_NETWORK_BYTE_ORDER;    data[0] = OX_BYTE_NETWORK_BYTE_ORDER;
   write(fd,data,1);    {int r; r=write(fdOut,data,1);}
   fsync(fd);  /* returns 0 if normal. Does it work for socket? */    fsync(fdOut);  /* returns 0 if normal. Does it work for socket? */
   
   read(fd,data,1);    {int r; r=read(fdIn,data,1);} /* Read pear's byte order */
   
   return(OX_BYTE_NETWORK_BYTE_ORDER);    return(OX_BYTE_NETWORK_BYTE_ORDER);
 }  }
   
   
   struct object OxClientList[MAX_N_OF_CLIENT];
   int OxClientListn = 0;
   
   int oxGetClientID() {
     extern struct object OxClientList[];
     extern int OxClientListn;
     extern struct object Nobj;
     int i;
     for (i=0; i<OxClientListn; i++) {
           if ((OxClientList[i]).tag == Snull) {
             return i;
           }
     }
     i = OxClientListn;
     (OxClientList[i]).tag = Snull;
     if (OxClientListn < MAX_N_OF_CLIENT-1) {
           OxClientListn++;
           return i;
     }else{
           fprintf(MyErrorOut,"oxGetClientID(): the client table is full. Returns ID = 0.\n");
           return 0;
     }
   }
   
   char *oxFIDtoStr(int id) {
     switch( id ) {
     case SM_mathcap:
       return "SM_mathcap"; break;
     case SM_setMathCap:
       return "SM_setMathCap"; break;
     case SM_pops:
       return "SM_pops"; break;
     case SM_getsp:
       return "SM_getsp"; break;
     case SM_dupErrors:
       return "SM_dupErrors"; break;
     case SM_pushCMOtag:
       return "SM_pushCMOtag"; break;
     case SM_setName:
       return "SM_setName"; break;
     case SM_evalName:
       return "SM_evalName"; break;
     case SM_executeStringByLocalParser:
       return "SM_executeStringByLocalParser"; break;
     case SM_executeFunction:
       return "SM_executeFunction"; break;
     case SM_executeFunctionWithOptionalArgument:
       return "SM_executeFunctionWithOptionalArgument"; break;
     case SM_popCMO:
       return "SM_popCMO"; break;
     case SM_popString:
       return "SM_popString"; break;
     case SM_shutdown:
       return "SM_shutdown"; break;
     case SM_beginBlock:
       return "SM_beginBlock"; break;
     case SM_endBlock:
       return "SM_endBlock"; break;
     default:
       return "Unknown to oxFIDtoStr"; break;
     }
   }
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.32
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>