| version 1.1.1.1, 1999/10/08 02:12:05 | 
version 1.9, 2001/05/04 01:06:30 | 
 | 
 | 
|   | 
 /*  $OpenXM: OpenXM/src/kan96xx/plugin/oxmisc.c,v 1.8 2000/12/03 07:29:39 takayama Exp $ */ | 
|  #include <stdio.h> | 
 #include <stdio.h> | 
|  #include <sys/types.h> | 
 #include <sys/types.h> | 
|  #include <sys/stat.h> | 
 #include <sys/stat.h> | 
 | 
 | 
|  #include <unistd.h> | 
 #include <unistd.h> | 
|  #include <signal.h> | 
 #include <signal.h> | 
|  #include <setjmp.h> | 
 #include <setjmp.h> | 
|  FILE *MyErrorOut = stdout; | 
 #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 21  FILE *MyErrorOut = stdout; | 
 
  | 
| Line 24  FILE *MyErrorOut = stdout; | 
 
 
 | 
|   | 
  | 
|  #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 39  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 48  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 68  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 94  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 127  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 140  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 168  int oxWaitSyncBall(ox_stream ostream) | 
 
  | 
| Line 175  int oxWaitSyncBall(ox_stream ostream) | 
 
 
 | 
|    int mtag; | 
   int mtag; | 
|    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); | 
     fprintf(stderr,"Looking for the next message tag. mtag=%d\n",mtag); | 
|            /* or stdout */ | 
     /* or stdout */ | 
|      fflush(NULL); | 
     fflush(NULL); | 
|    } | 
   } | 
|  } | 
 } | 
| Line 178  int oxWaitSyncBall_org(ox_stream ostream) | 
 
  | 
| Line 185  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 208  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 334  void oxSendResultOfControl(int fd)  | 
 
  | 
| Line 342  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; | 
|    /* printf("ox sending mathcap\n"); fflush(stdout); */ | 
   /* printf("ox sending mathcap\n"); fflush(stdout); */ | 
|    mathinfo = *((struct object *)(mathcap->infop)); | 
   mathinfo = *((struct object *)(mathcap->infop)); | 
| Line 363  void oxSendMathCap(ox_stream os,struct mathCap *mathca | 
 
  | 
| Line 371  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 473  void oxReqPopCMO(ox_stream os) { | 
 
  | 
| Line 481  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 493  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; | 
| Line 493  int oxclientMultiSelect(oxclientp clients[],int datare | 
 
  | 
| Line 502  int oxclientMultiSelect(oxclientp clients[],int datare | 
 
 
 | 
|    struct timeval timeout; | 
   struct timeval timeout; | 
|    extern int errno; | 
   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 517  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 567  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 595  int oxIsThereErrorClient(oxclientp client) { | 
 
  | 
| Line 609  int oxIsThereErrorClient(oxclientp client) { | 
 
 
 | 
|  } | 
 } | 
|   | 
  | 
|  oxclientp oxCreateClient(char *sname,int portStream,int portControl) | 
 oxclientp oxCreateClient(char *sname,int portStream,int portControl) | 
|    /* you also need to change oxCreateClient2. */ | 
      /* you also need to change oxCreateClient2. */ | 
|  { | 
 { | 
|    static int clnum = 0; | 
   static int clnum = 0; | 
|    int v = 0; | 
   int v = 0; | 
| Line 621  oxclientp oxCreateClient(char *sname,int portStream,in | 
 
  | 
| Line 635  oxclientp oxCreateClient(char *sname,int portStream,in | 
 
 
 | 
|   | 
  | 
|    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 707  oxclientp oxCreateClientFile(char *fname,char *mode,ch | 
 
  | 
| Line 721  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 829  char *oxGenPortFile(void) { | 
 
  | 
| Line 843  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 866  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; | 
|    srandom((unsigned int) seed); | 
   if (seed == 0) { | 
|   | 
     seed = (int) time(NULL) + (int) &p; | 
|   | 
     srandom((unsigned int) seed); | 
|   | 
   } | 
|   | 
   for (i=0; i < ((int) &p) % 100 ; i++) random(); | 
|    p = random(); | 
   p = random(); | 
|    s = (char *)malloc(128*sizeof(char)); | 
   s = (char *)malloc(128*sizeof(char)); | 
|    sprintf(s,"%ld",p); | 
   sprintf(s,"%ld",p); | 
| Line 871  static void cancelConnection() { | 
 
  | 
| Line 890  static void cancelConnection() { | 
 
 
 | 
|  } | 
 } | 
|   | 
  | 
|  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 *pass) | 
|  { | 
 { | 
|    static int clnum = 0; | 
   static int clnum = 0; | 
|    int v = 0; | 
   int v = 0; | 
| Line 910  oxclientp oxCreateClient2(int fdstream,int portStream, | 
 
  | 
| Line 929  oxclientp oxCreateClient2(int fdstream,int portStream, | 
 
 
 | 
|      return(NULL); | 
     return(NULL); | 
|    } | 
   } | 
|   | 
  | 
|    /* Authentification by password. */ | 
   /* Authentication by password. */ | 
|    m = strlen(pass); | 
   m = strlen(pass); | 
|    s = (char *)mymalloc(sizeof(char)*(m+1)); | 
   s = (char *)mymalloc(sizeof(char)*(m+1)); | 
|    read(fdControl,s,m); s[m] = '\0'; | 
   read(fdControl,s,m+1); s[m] = '\0'; | 
|    if (strcmp(s,pass) != 0) { | 
   if (strcmp(s,pass) != 0) { | 
|      fprintf(stderr,"oxCreateClient2(): password authentification failed for control channel.\n"); | 
     fprintf(stderr,"oxCreateClient2(): password authentication failed for control channel.\n"); | 
|      close(fdControl); | 
     close(fdControl); | 
|      return(NULL); | 
     return(NULL); | 
|    } | 
   } | 
|    read(fdStream,s,m); s[m] = '\0'; | 
   read(fdStream,s,m+1); s[m] = '\0'; | 
|    if (strcmp(s,pass) != 0) { | 
   if (strcmp(s,pass) != 0) { | 
|      fprintf(stderr,"oxCreateClient2(): password authentification failed for data channel.\n"); | 
     fprintf(stderr,"oxCreateClient2(): password authentication failed for data channel.\n"); | 
|      close(fdStream); | 
     close(fdStream); | 
|      return(NULL); | 
     return(NULL); | 
|    } | 
   } | 
| Line 929  oxclientp oxCreateClient2(int fdstream,int portStream, | 
 
  | 
| Line 948  oxclientp oxCreateClient2(int fdstream,int portStream, | 
 
 
 | 
|   | 
  | 
|    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)); |