===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/plugin/oxmisc2.c,v
retrieving revision 1.1.1.1
retrieving revision 1.27
diff -u -p -r1.1.1.1 -r1.27
--- OpenXM/src/kan96xx/plugin/oxmisc2.c	1999/10/08 02:12:05	1.1.1.1
+++ OpenXM/src/kan96xx/plugin/oxmisc2.c	2013/11/06 06:23:24	1.27
@@ -1,8 +1,14 @@
+/* $OpenXM: OpenXM/src/kan96xx/plugin/oxmisc2.c,v 1.26 2005/07/03 11:08:54 ohara Exp $ */
 #include <stdio.h>
+#include <string.h>
 #include "ox_kan.h"
 #include "oxmisc2.h"   /* This file requires sm1 object description. */
 #include "cmo.h"
+
 extern FILE *MyErrorOut;
+#define SET_MYERROROUT { if (MyErrorOut == NULL) MyErrorOut=stdout; }
+/* It is also defined in oxmisc.c */
+
 extern int SerialOX; /* defined in SerialOX */
 
 extern int OxVersion;
@@ -12,13 +18,13 @@ int DebugMathCap = 1;
 
 
 int oxGet(oxclientp client, struct object *op,int *isObj)
-/* This method should be synchronized. */
-/* oxGet is a function for client. */
+     /* This method should be synchronized. */
+     /* oxGet is a function for client. */
 {
   int ans;
   ox_stream os;
   int m;
-  struct object rob;
+  struct object rob = OINIT;
   int sss;  /* Serial number of the recieved packet. */
   *isObj = 0;
   op->tag = Snull;
@@ -67,6 +73,7 @@ int oxGet(oxclientp client, struct object *op,int *isO
 int oxGetFromControl(oxclientp client)
 {
   int ans = -1;
+  AbortIfRFC_101(client);
   if (client->cstate != -1) {
     ans = oxGetResultOfControlInt32(client->controlfd);
     if (ans != -1) {    client->cstate = 0; }
@@ -78,13 +85,15 @@ int oxGetFromControl(oxclientp client)
 int oxReq(oxclientp client,int func,struct object ob)
 {
   struct object *ob1p;
+  SET_MYERROROUT;
   /* request to the control channel */
   if (func == SM_control_reset_connection ||
       func == SM_control_kill) {
+    AbortIfRFC_101(client);
     switch(func) {
     case SM_control_reset_connection:
       oxReqControlResetConnection(client->controlfd);
-      client->cstate = 1;
+      client->cstate = 0;
       client->dstate = DSTATE_FIRST_SYNC;
       break;
     case SM_control_kill:
@@ -127,48 +136,67 @@ int oxReq(oxclientp client,int func,struct object ob)
     break;
   case SM_setMathCap:
     /* ob = [(mathcap-obj) [[version num, system name] [sm tags]
-                             ob1                        smtags
-                                                [[ox numbers] [cmo numbers]]]
-                                                    ob3         ob2 */
+       ob1                        smtags
+       oxtags      [[ox numbers, [cmo numbers]]]
+       ob3         ob2 */
+    /*     oxtags      [[OX_DATA, [cmo numbers]],[OX_DATA_LOCAL,[opt]],...]*/
     {
-      struct object ob1;
-      struct object ob2;
-      struct object ob3;
-      struct object smtags;
-    int n,i;
-    struct mathCap mathcap;
+      struct object ob1 = OINIT;
+      struct object ob2 = OINIT;
+      struct object ob3 = OINIT;
+      struct object obm = OINIT;
+      struct object smtags = OINIT;
+      struct object oxtags = OINIT;
+      struct object ox = OINIT;
+      int n,i;
+      struct mathCap mathcap;
 
-    if (strcmp(KopString(getoa(ob,0)),"mathcap-object") != 0) {
-      errorOxmisc2("data format error in oxReqSetMathCap");
-      client->dstate = DSTATE_ANY;
-      break;
-    }
-      ob1 = getoa(getoa(ob,1),0);
-      smtags = getoa(getoa(ob,1),1);
-      ob2 = getoa(getoa(getoa(ob,1),2),1);
-      ob3 = getoa(getoa(getoa(ob,1),2),0);
-      
+      if (strcmp(KopString(getoa(ob,0)),"mathcap-object") != 0) {
+        errorOxmisc2("data format error in oxReqSetMathCap");
+        client->dstate = DSTATE_ANY;
+        break;
+      }
+      obm = getoa(ob,1);
+      ob1 = getoa(obm,0);
+      smtags = getoa(obm,1);
+      oxtags = getoa(obm,2);
+      if (smtags.tag != Sarray || oxtags.tag != Sarray) {
+        errorOxmisc2("data format error in oxReqSetMathCap");
+      }
       ob1p = (struct object *) sGC_malloc(sizeof(struct object));
       *ob1p = ob1;
       mathcap.infop = ob1p;
-      n = getoaSize(ob2);
-      mathcap.n = n;
+
+      n = getoaSize(oxtags);
       if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
-      for (i=0; i<n; i++) {
-	mathcap.cmo[i] = KopInteger(getoa(ob2,i));
-      }
-      n = getoaSize(ob3);
-      if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
       mathcap.oxSize = n;
       for (i=0; i<n; i++) {
-	mathcap.ox[i] = KopInteger(getoa(ob3,i));
+        ox = getoa(oxtags,i);
+        if (ox.tag != Sarray) {
+          errorOxmisc2("Data format error of the third argument of mathcap.");
+        }
+        mathcap.ox[i] = KopInteger(getoa(ox,0));
+        if (mathcap.ox[i] == OX_DATA) {
+          if (getoaSize(ox) < 2) {
+            errorOxmisc2("Data format error in an entry of the third argument of mathcap.");
+          }
+          ob2 = getoa(ox,1);
+          if (ob2.tag != Sarray) {
+            errorOxmisc2("Data format error in an entry of the third argument of mathcap.");
+          }
+          mathcap.n = getoaSize(ob2);
+          if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
+          for (i=0; i<mathcap.n; i++) {
+            mathcap.cmo[i] = KopInteger(getoa(ob2,i));
+          }
+        }
       }
 
       n = getoaSize(smtags);
       if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
       mathcap.smSize = n;
       for (i=0; i<n; i++) {
-	mathcap.sm[i] = KopInteger(getoa(smtags,i));
+        mathcap.sm[i] = KopInteger(getoa(smtags,i));
       }
 
       oxReqSetMathCap(client->datafp2,&mathcap);
@@ -199,6 +227,14 @@ int oxReq(oxclientp client,int func,struct object ob)
     oxReqExecuteFunction(client->datafp2,KopString(ob));
     client->dstate = DSTATE_ANY;
     break;
+  case SM_executeFunctionWithOptionalArgument:
+    if (ob.tag != Sdollar) {
+      errorOxmisc2("SM_executeFunctionWithOptionalArgument : the argument must be a string.");
+      return(-1);
+    }
+    oxReqExecuteFunctionWithOptionalArgument(client->datafp2,KopString(ob));
+    client->dstate = DSTATE_ANY;
+    break;
   case SM_popString:
     oxReqPopString(client->datafp2);
     client->dstate = DSTATE_ANY;
@@ -227,6 +263,10 @@ int oxReq(oxclientp client,int func,struct object ob)
     oxReqSingleOperand(client->datafp2,SM_dupErrors);
     client->dstate = DSTATE_ANY;
     break;
+  case SM_pushCMOtag:
+    oxReqSingleOperand(client->datafp2,SM_pushCMOtag);
+    client->dstate = DSTATE_ANY;
+    break;
   default:
     fprintf(MyErrorOut,"func=%d ",func);
     errorOxmisc2("This function is not implemented.");
@@ -237,11 +277,14 @@ int oxReq(oxclientp client,int func,struct object ob)
 }
 
 struct object KoxCreateClient(struct object ip,
-			      struct object portStream,
-			      struct object portControl)
+                              struct object portStream,
+                              struct object portControl,struct object pass)
 {
-  struct object rob;
+  struct object rob = OINIT;
   oxclientp client;
+  char *passControl; char *passData;
+  struct object tob = OINIT;
+  passControl = NULL; passData = NULL;
   rob.tag = Snull;
   if (ip.tag != Sdollar) {
     errorOxmisc2("KoxCreateClient(): The first argument must be a hostname given by a string.");
@@ -249,7 +292,7 @@ struct object KoxCreateClient(struct object ip,
   }
   if (portStream.tag == Sdollar) {
     client = oxCreateClientFile(KopString(ip),KopString(portStream),
-				"/dev/null","w");
+                                "/dev/null","w");
     if (client == NULL) {
       errorOxmisc2("KoxCreateClient(): Open error.");
       return(rob);
@@ -267,13 +310,32 @@ struct object KoxCreateClient(struct object ip,
     errorOxmisc2("KoxCreateClient(): The third argument must be a port number given in an integer.");
     return(rob);
   }
-  client = oxCreateClient(KopString(ip),KopInteger(portStream),KopInteger(portControl));
+  if (pass.tag == Sarray) {
+    if (getoaSize(pass) < 2) {
+	  errorOxmisc2("KoxCreateClient(): the fourth argument --- pass must be an array of strings.");
+	  return rob;
+	}
+    tob = getoa(pass,0);
+	if (tob.tag != Sdollar) {
+	  errorOxmisc2("KoxCreateClient(): the fourth argument --- pass must be an array of strings.");
+	  return rob;
+	}
+    passControl = KopString(tob);
+    tob = getoa(pass,1);
+	if (tob.tag != Sdollar) {
+	  errorOxmisc2("KoxCreateClient(): the fourth argument --- pass must be an array of strings.");
+	  return rob;
+	}
+    passData = KopString(tob);
+  }
+  client = oxCreateClient(KopString(ip),KopInteger(portStream),KopInteger(portControl),passControl,passData);
   if (client == NULL) {
     errorOxmisc2("KoxCreateClient(): Open error.");
     return(rob);
   }
   rob = newObjectArray(N_OF_CLIENT_FIELDS);
   oxClientToObject(client,rob);
+  oxClientListUpdate(rob);
   return(rob);
 }
 
@@ -305,7 +367,7 @@ static int isItClientObject(struct object ob)
 
 struct object KoxIsThereErrorClient(struct object ob)
 {
-  struct object rob;
+  struct object rob = OINIT;
   int ans;
   int size;
   oxclient cc;
@@ -321,8 +383,8 @@ struct object KoxIsThereErrorClient(struct object ob)
 
 int oxClientToObject(oxclientp client,struct object rob)
 {
-  struct object ob;
-  if (client == NULL) return;
+  struct object ob = OINIT;
+  if (client == NULL) return 0;
   /* rob = newObjectArray(N_OF_CLIENT_FIELDS); */
   if (rob.tag != Sarray) {
     errorOxmisc2("oxClientToObject(): the second argument must be an array.");
@@ -354,12 +416,13 @@ int oxClientToObject(oxclientp client,struct object ro
   }
   putoa(rob,11,KpoInteger(client->engineByteOrder));
   putoa(rob,12,KpoInteger(client->controlByteOrder));
+  putoa(rob,13,KpoInteger(client->engineID));
   return(0);
 }
 
 int oxObjectToClient(struct object ob,oxclientp cp)
 {
-  struct object ob1;
+  struct object ob1 = OINIT;
   struct object *obp;
   if (cp == NULL) {
     errorOxmisc2("oxObjectToClient(): the second argument is NULL");
@@ -410,18 +473,21 @@ int oxObjectToClient(struct object ob,oxclientp cp)
   cp->engineByteOrder = KopInteger(ob1);
   ob1 = getoa(ob,12);
   cp->controlByteOrder = KopInteger(ob1);
+
+  ob1 = getoa(ob,13);
+  cp->engineID = KopInteger(ob1);
   
 
   return(0);
 }
 
 struct object KoxReq(struct object client,
-		     struct object func,
-		     struct object ob1)
+                     struct object func,
+                     struct object ob1)
 {
   int ans;
   static oxclientp cc1 = NULL;
-  struct object rob;
+  struct object rob = OINIT;
   rob.tag = Snull;
   if (cc1 == NULL) {
     cc1 = (oxclientp) mymalloc(sizeof(oxclient));
@@ -452,7 +518,7 @@ struct object KoxGet(struct object client)
 {
   int ans,k;
   static oxclientp cc1 = NULL;
-  struct object rob;
+  struct object rob = OINIT;
   rob.tag = Snull;
   if (cc1 == NULL) {
     cc1 = (oxclientp) mymalloc(sizeof(oxclient));
@@ -483,7 +549,7 @@ struct object KoxGetFromControl(struct object client)
 {
   int ans;
   static oxclientp cc1 = NULL;
-  struct object rob;
+  struct object rob = OINIT;
   rob.tag = Snull;
   if (cc1 == NULL) {
     cc1 = (oxclientp) mymalloc(sizeof(oxclient));
@@ -513,12 +579,12 @@ struct object KoxMultiSelect(struct object oclients,st
   static int csize = 0;
   static oxclientp *clients = NULL;
   oxclientp cc1;
-  struct object rob;
+  struct object rob = OINIT;
   int i;
   int tt;
-  struct object ob1;
-  struct object ob2;
-  struct object ob0;
+  struct object ob1 = OINIT;
+  struct object ob2 = OINIT;
+  struct object ob0 = OINIT;
   int size;
   int ans;
   int dataready[1024];
@@ -533,15 +599,15 @@ struct object KoxMultiSelect(struct object oclients,st
   if (first) {
     first = 0; csize = size;
     clients = (oxclientp *)mymalloc(sizeof(oxclientp)*(size+1));
-     if (clients == NULL) {
+    if (clients == NULL) {
       errorOxmisc2("KoxMultiSelect(): no more memory.");
       return(rob);
     }
     for (i=0; i<size; i++) {
       clients[i] =  (oxclientp) mymalloc(sizeof(oxclient));
       if (clients[i] == NULL) {
-	errorOxmisc2("KoxMultiSelect(): no more memory.");
-	return(rob);
+        errorOxmisc2("KoxMultiSelect(): no more memory.");
+        return(rob);
       }
       oxInitClient(clients[i]);
     }
@@ -579,12 +645,21 @@ struct object KoxMultiSelect(struct object oclients,st
 }
 
 struct object KoxWatch(struct object client,struct object f)
-/* f is not used for now. It should be log file. */
+     /* f is not used for now. It should be log file. */
 {
   int ans,k;
   static oxclientp cc1 = NULL;
-  struct object rob;
+  struct object rob = OINIT;
+  extern int WatchStream;
   rob.tag = Snull;
+  if (client.tag == Sinteger) {
+    if (KopInteger(client)) {
+      WatchStream = 1;
+    }else{
+      WatchStream = 0;
+    }
+    return rob;
+  }
   if (cc1 == NULL) {
     cc1 = (oxclientp) mymalloc(sizeof(oxclient));
     if (cc1 == NULL) {
@@ -607,11 +682,68 @@ struct object KoxWatch(struct object client,struct obj
   return(KpoInteger(ans));
 }
 
+struct object KoxLog(struct object client,struct object in,struct object out)
+{
+  int ans,k;
+  static oxclientp cc1 = NULL;
+  struct object rob = OINIT;
+  rob.tag = Snull;
+  if (cc1 == NULL) {
+    cc1 = (oxclientp) mymalloc(sizeof(oxclient));
+    if (cc1 == NULL) {
+      errorOxmisc2("KoxLog(): no more memory.");
+      return(rob);
+    }
+    oxInitClient(cc1);
+  }
+
+  if (oxObjectToClient(client,cc1) == -1) return(rob);
+  if (cc1 == NULL) {
+    errorOxmisc2("KoxLog(): the first argument must be a client object.");
+    return(rob);
+  }
+
+  if (in.tag != Sfile) {
+	errorOxmisc2("KoxLog(): the second argument is not a file object.");
+	return rob;
+  }
+  if (out.tag != Sfile) {
+	errorOxmisc2("KoxLog(): the third argument is not a file object.");
+	return rob;
+  }
+  k = fp2log(cc1->datafp2,in.rc.file,out.rc.file);
+  fputc(cc1->engineByteOrder,out.rc.file); /* Output engineByteOrder. */
+  /* synchronize cc1 and client. */
+  oxClientToObject(cc1,client);
+
+  return(KpoInteger(ans));
+}
+
+struct object KoxLogStop(struct object client) {
+  static oxclientp cc1 = NULL;
+  struct object rob = OINIT;
+  rob.tag = Snull;
+  if (cc1 == NULL) {
+    cc1 = (oxclientp) mymalloc(sizeof(oxclient));
+    if (cc1 == NULL) {
+      errorOxmisc2("KoxLog(): no more memory.");
+      return(rob);
+    }
+    oxInitClient(cc1);
+  }
+
+  if (oxObjectToClient(client,cc1) == -1) return(rob);
+  if (cc1 == NULL) {
+    errorOxmisc2("KoxLog(): the first argument must be a client object.");
+    return(rob);
+  }
+  return(KpoInteger(fp2stopLog(cc1->datafp2)));  
+}
     
 struct object KoxCloseClient(struct object client) {
   oxclientp cc1 = NULL;
   oxclient cc;
-  struct object rob;
+  struct object rob = OINIT;
   rob.tag = Snull;
   cc1  = &cc;
   if (oxObjectToClient(client,cc1) == -1) return(rob);
@@ -638,6 +770,7 @@ struct object KoxCloseClient(struct object client) {
     errorOxmisc2("Unknown client->type\n");
     break;
   }
+  oxClientListRemove(client);
   return(KpoInteger(0));
 
 }
@@ -648,7 +781,9 @@ static int cmoCheck00(struct object obj,int cmo[], int
 #define CHECK00_N  4098      /* look up stackm.h and kclass.h */
   static int typeTrans[CHECK00_N]; 
   static int init = 0;
-  if (n == 0) return(1);  /* For null cmolist, OK. */
+  /* if n == 0, report the cmo tag of the object obj.
+     If it cannot be translated to cmo, then return -1. */
+
   if (!init) {
     for (i=0; i<CHECK00_N; i++) {
       typeTrans[i] = 0;  /* unknown cmo number */
@@ -665,6 +800,7 @@ static int cmoCheck00(struct object obj,int cmo[], int
     /* typeTrans[Spoly] = CMO_DMS;  */
     typeTrans[Spoly] = CMO_DISTRIBUTED_POLYNOMIAL; 
     typeTrans[Sdouble] = CMO_64BIT_MACHINE_DOUBLE;
+	typeTrans[SrationalFunction] = CMO_RATIONAL;
     typeTrans[CLASSNAME_ERROR_PACKET]   = CMO_ERROR2;
     typeTrans[CLASSNAME_mathcap] = CMO_MATHCAP; 
     typeTrans[CLASSNAME_indeterminate] = CMO_INDETERMINATE; 
@@ -677,16 +813,21 @@ static int cmoCheck00(struct object obj,int cmo[], int
   if (obj.tag == Sclass) {
     ttt = typeTrans[ectag(obj)];
   }
+  /* Only report the cmo tag. */
+  if (n == 0) {
+    if (ttt == 0) return(-1);
+    else return(ttt);
+  }
 
   for (i=0; i<n; i++) {
     if (ttt == cmo[i]) {
       if (ttt != CMO_LIST) return(1);
       else {
-	m = getoaSize(obj);
-	for (j=0; j<m; j++) {
-	  if (!cmoCheck00(getoa(obj,j),cmo,n)) return(0);
-	}
-	return(1);
+        m = getoaSize(obj);
+        for (j=0; j<m; j++) {
+          if (!cmoCheck00(getoa(obj,j),cmo,n)) return(0);
+        }
+        return(1);
       }
     }
   }
@@ -694,7 +835,7 @@ static int cmoCheck00(struct object obj,int cmo[], int
     if (DebugMathCap && 1) {
       fprintf(stderr,"Type translation table (internal object tag --> CMO tag)\n");
       for (i=0; i<20; i++) {
-	printf("%d ", typeTrans[i]);
+        printf("%d ", typeTrans[i]);
       }
       printf("\n");
     }
@@ -711,13 +852,20 @@ static int cmoCheck00(struct object obj,int cmo[], int
     
 int cmoCheckMathCap(struct object obj, struct object *obp)
 {
-  struct object mathcap;
-  struct object cmolist;
+  struct object mathcap = OINIT;
+  struct object cmolist = OINIT;
+  struct object mathcapMain = OINIT;
+  struct object mathcapThird = OINIT;
+  struct object ox = OINIT;
+  struct object oxtag = OINIT;
+  struct object ob0 = OINIT;
+  int oxsize;
   int n;
   int i;
 #define CMO_CHECK_MATH_CAP_LIST_SIZE 1024
   int cmo[CMO_CHECK_MATH_CAP_LIST_SIZE];
   if (obp == NULL) return(1);
+  /* printObject(*obp,0,stderr); for debug*/
   if (obp->tag != Sarray) {
     fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
     printObject(*obp,0,stderr);
@@ -725,6 +873,15 @@ int cmoCheckMathCap(struct object obj, struct object *
     errorOxmisc2("cmoCheckMathCap: format error in the client->mathcapObjp field.\n");
   }
   mathcap = *obp;
+  /* Example of mathcap 
+     [    $mathcap-object$ ,
+     [    [    199909080 , $Ox_system=ox_sm1.plain$ , $Version=2.991106$ , 
+     $HOSTTYPE=i386$ ]  , 
+     [    262 , 263 , 264 , 265 , 266 , 268 , 269 , 272 , 273 , 275 , 
+     276 ]  , 
+     [    [    514  , [    2130706434 , 1 , 2 , 4 , 5 , 17 , 19 , 20 , 22 , 23 , 24 , 25 , 26 , 30 , 31 , 60 , 61 , 27 , 33 , 40 , 16 , 34 ] ] ]  ]  ]
+  */
+
   n = getoaSize(mathcap);
   if (n < 2) {
     fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
@@ -732,39 +889,88 @@ int cmoCheckMathCap(struct object obj, struct object *
     fprintf(stderr,"\n");
     errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n");
   }
-  /* I should check 
-         getoa(getoa(mathcap,2),0)
-     contains OX_DATA.
-     It has not yet implemented.
-  */
-  mathcap = getoa(getoa(mathcap,1),2);
-  n = getoaSize(mathcap);
-  if (n < 2) {
+  ob0 = getoa(mathcap,0);
+  if (ob0.tag != Sdollar) {
     fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
     printObject(*obp,0,stderr);
     fprintf(stderr,"\n");
-    errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n");
+    errorOxmisc2("cmoCheckMathCap: The first field must be the string mathcap-object.\n");
   }
-  cmolist = getoa(mathcap,1);
-  if (cmolist.tag != Sarray) {
+  if (strcmp(KopString(ob0),"mathcap-object") != 0) {
     fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
     printObject(*obp,0,stderr);
     fprintf(stderr,"\n");
-    errorOxmisc2("cmoCheckMathCap: mathcap[1] must be an array of integers.\n");
+    errorOxmisc2("cmoCheckMathCap: The mathcap must be of the form [(mathcap-object) [...]]\n");
   }
-  n = getoaSize(cmolist);
-  if (n > CMO_CHECK_MATH_CAP_LIST_SIZE) {
-    errorOxmisc2("cmoCheckMathCap: Too big cmo list.\n");
+    
+  /* I should check 
+     getoa(getoa(mathcap,1),2)
+     contains OX_DATA.
+     It has not yet implemented.
+  */
+  mathcapMain = getoa(mathcap,1);
+  if (mathcapMain.tag != Sarray) {
+    fprintf(stderr,"cmoCheckMathCap: mathcap[1] is \n");
+    printObject(mathcapMain,0,stderr);
+    fprintf(stderr,"\n");
+    errorOxmisc2("cmoCheckMathCap: format error in the (client->mathcapObjp)[1] field. It should be an array.\n");
   }
-  for (i=0; i<n; i++) {
-    cmo[i] = KopInteger(getoa(cmolist,i));
+  if (getoaSize(mathcapMain) < 3) {
+    fprintf(stderr,"cmoCheckMathCap: mathcap[1] is \n");
+    printObject(mathcapMain,0,stderr);
+    fprintf(stderr,"\n");
+    errorOxmisc2("cmoCheckMathCap: format error in the (client->mathcapObjp)[1] field. It should be an array of which length is more than 2.\n");
   }
+  mathcapThird = getoa(mathcapMain,2);
+  oxsize = getoaSize(mathcapThird);
+  for (i=0; i<oxsize; i++) {
+    ox = getoa(mathcapThird,i);
+    if (ox.tag != Sarray) {
+      fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
+      printObject(*obp,0,stderr);
+      fprintf(stderr,"\n");
+      errorOxmisc2("cmoCheckMathCap: the third element of mathcap is a list of lists.");
+    }
+    if (getoaSize(ox) != 0) {
+      oxtag = getoa(ox,0);
+      if (oxtag.tag != Sinteger) {
+        fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
+        printObject(*obp,0,stderr);
+        fprintf(stderr,"\n");
+        errorOxmisc2("cmoCheckMathCap: the third element of mathcap must be [OX_DATA_xxx, [  ]].");
+      }
+      if (KopInteger(oxtag) == OX_DATA) {
+        if (getoaSize(ox) > 1) {
+          cmolist = getoa(ox,1);
+          if (cmolist.tag != Sarray) {
+            fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
+            printObject(*obp,0,stderr);
+            fprintf(stderr,"\n");
+            errorOxmisc2("cmoCheckMathCap: mathcap[1] must be an array of integers.\n");
+          }
+          n = getoaSize(cmolist);
+          if (n > CMO_CHECK_MATH_CAP_LIST_SIZE) {
+            errorOxmisc2("cmoCheckMathCap: Too big cmo list.\n");
+          }
+          for (i=0; i<n; i++) {
+            cmo[i] = KopInteger(getoa(cmolist,i));
+          }
+        }else{
+          fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
+          printObject(*obp,0,stderr);
+          fprintf(stderr,"\nox=");
+          printObject(ox,0,stderr);
+          errorOxmisc2("cmoCheckMathCap: [OX_DATA, cmolist]");
+        }
+      }
+    }
+  }
   return(cmoCheck00(obj,cmo,n));
 }
     
-		     
+             
 struct object KoxGenPortFile(void) {
-  struct object ob;
+  struct object ob = OINIT;
   ob = KpoString(oxGenPortFile());
   return(ob);
 }
@@ -774,20 +980,20 @@ void KoxRemovePortFile(void) {
 
 void oxPushMathCap(struct mathCap *mathcap)
 {
-  struct object rob;
+  struct object rob = OINIT;
   rob = newMathCap(mathcap); 
   Kpush(rob);
 }
 
 struct object KoxGenPass(void) {
-  struct object rob;
+  struct object rob = OINIT;
   rob = KpoString(oxGenPass());
   return(rob);
 }
 
 struct object KoxGetPort(struct object host)
 {
-  struct object rob;
+  struct object rob = OINIT;
   int fdStream, fdControl;
   int portStream, portControl;
   extern int OpenedSocket;
@@ -809,16 +1015,38 @@ struct object KoxGetPort(struct object host)
   putoa(rob,3,KpoInteger(portControl));
   return(rob);
 }
+struct object KoxGetPort1(struct object host)
+{
+  struct object rob = OINIT;
+  int fdStream;
+  int portStream;
+  extern int OpenedSocket;
+  char *sname;
+  rob = NullObject;
+  if (host.tag != Sdollar) {
+    errorOxmisc2("KoxGetPort1: argument is not a string.");
+    return(rob);
+  }
+  sname = KopString(host);
+  fdStream = socketOpen(sname,0);
+  portStream = OpenedSocket;
+  rob = newObjectArray(2);
+  putoa(rob,0,KpoInteger(fdStream));
+  putoa(rob,1,KpoInteger(portStream));
+  return(rob);
+}
 
 struct object KoxCreateClient2(struct object peer,
-			       struct object ipmask,
-			       struct object pass)
+                               struct object ipmask,
+                               struct object pass)
 {
-  struct object rob;
+  struct object rob = OINIT;
   oxclientp client;
   int fdStream, portStream, fdControl, portControl;
   int i;
-  struct object ob1;
+  struct object ob1 = OINIT;
+  struct object opassControl = OINIT;
+  struct object opassData = OINIT;
   rob.tag = Snull;
   if (peer.tag != Sarray) {
     errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl]");
@@ -842,22 +1070,405 @@ struct object KoxCreateClient2(struct object peer,
   if (ipmask.tag != Sinteger) {
     errorOxmisc2("KoxCreateClient2(): ipmask must be an integer.");
   }
-  if (pass.tag != Sdollar) {
-    errorOxmisc2("KoxCreateClient2(): pass must be a string.");
+  if (pass.tag == Sdollar) {
+    opassControl = pass; opassData = pass;
+  }else if (pass.tag == Sarray) {
+    if (getoaSize(pass) < 2) errorOxmisc2("KoxCreateClient2: #passArray < 2.");
+    opassControl = getoa(pass,0);
+    opassData = getoa(pass,1);
+  }else{
+    errorOxmisc2("KoxCreateClient2(): pass must be a string or an array.");
   }
+  if ((opassControl.tag != Sdollar) || (opassData.tag != Sdollar)) {
+    errorOxmisc2("KoxCreateClient2(): opassControl or opassData must be a string.");
+  }
 
   client = oxCreateClient2(fdStream, portStream, fdControl, portControl,
-			   KopInteger(ipmask), KopString(pass));
+                           KopInteger(ipmask),
+                           KopString(opassControl),KopString(opassData));
   if (client == NULL) {
     errorOxmisc2("KoxCreateClient2(): Open error.");
     return(rob);
   }
   rob = newObjectArray(N_OF_CLIENT_FIELDS);
   oxClientToObject(client,rob);
+  oxClientListUpdate(rob);
   return(rob);
 }
 
+int KgetCmoTagOfObject(struct object obj) {
+  int k;
+  k=cmoCheck00(obj,(int *)NULL,0);
+  return(k);
+}
+
 errorOxmisc2(char *s) {
+  SET_MYERROROUT;  
   fprintf(MyErrorOut,"error in oxmisc2.c: %s\n",s);
   errorKan1("%s\n","  ");
 }
+
+struct object KoxPushCMD(struct object client,struct object cmd) {
+  int ans;
+  static oxclientp cc1 = NULL;
+  struct object rob = OINIT;
+  rob.tag = Snull;
+  if (cc1 == NULL) {
+    cc1 = (oxclientp) mymalloc(sizeof(oxclient));
+    if (cc1 == NULL) {
+      errorOxmisc2("KoxReq(): no more memory.");
+      return(rob);
+    }
+    oxInitClient(cc1);  /* BUG: is it fine? */
+  }
+
+  if (oxObjectToClient(client,cc1) == -1) return(rob);
+  if (cc1 == NULL) {
+    errorOxmisc2("KoxReq(): the first argument must be a client object.");
+    return(rob);
+  }
+  if (cmd.tag != Sinteger) {
+    errorOxmisc2("KoxReq(): the second argument must be an integer.");
+    return(rob);
+  }
+  /* BUG: check the mathcap */
+  oxSendOXheader(cc1->datafp2,OX_COMMAND,SerialOX++);
+  oxSendInt32(cc1->datafp2,KopInteger(cmd));
+  /* synchronize cc1 and client. */
+  oxClientToObject(cc1,client);
+  return(cmd);
+}
+
+struct object KoxPushCMO(struct object client,struct object ob) {
+  int ans;
+  static oxclientp cc1 = NULL;
+  struct object rob = OINIT;
+  rob.tag = Snull;
+  if (cc1 == NULL) {
+    cc1 = (oxclientp) mymalloc(sizeof(oxclient));
+    if (cc1 == NULL) {
+      errorOxmisc2("KoxReq(): no more memory.");
+      return(rob);
+    }
+    oxInitClient(cc1);  /* BUG: is it fine? */
+  }
+
+  if (oxObjectToClient(client,cc1) == -1) return(rob);
+  if (cc1 == NULL) {
+    errorOxmisc2("KoxReq(): the first argument must be a client object.");
+    return(rob);
+  }
+
+  /* request to the data channel */
+  if (cc1->dstate != DSTATE_ANY) {
+    errorOxmisc2("oxPushCMO: cc1->dstate != DSTATE_ANY, data channel is not ready to send data.\n");
+    return(rob);
+  }
+
+  if (!cmoCheckMathCap(ob,(struct object *)cc1->mathcapObjp)) {
+    errorOxmisc2("oxPushCMO: your peer does not understand this cmo.\n");
+    return(rob);
+  }
+  oxSendOXheader(cc1->datafp2,OX_DATA,SerialOX++);
+  cmoObjectToStream2(ob,cc1->datafp2);
+  /* synchronize cc1 and client. */
+  oxClientToObject(cc1,client);
+  return(ob);
+}
+
+oxclientp oxCreateControl_RFC_101(int fdstream,int portStream,
+                                  int ipmask,char *pass);
+struct object KoxCreateControl_RFC_101(struct object peer,struct object ipmask,struct object pass) 
+{
+  struct object rob = OINIT;
+  oxclientp client;
+  int fdStream, portStream;
+  int i;
+  struct object ob1 = OINIT;
+  rob.tag = Snull;
+  if (peer.tag != Sarray) {
+    errorOxmisc2("KoxCreateControl_RFC_101(): The first argument must be an array [fdStream, portStream]");
+    return(rob);
+  }
+  if (getoaSize(peer) != 2 ) {
+    errorOxmisc2("KoxCreateControl_RFC_101(): The first argument must be an array [fdStream, portStream] of size 2.");
+    return(rob);
+  }
+  for (i=0; i<getoaSize(peer); i++) {
+    ob1 = getoa(peer,i);
+    if (ob1.tag != Sinteger) {
+      errorOxmisc2("KoxCreateControl_RFC_101(): The element of the first argument must be an integer.");
+    }
+  }
+  fdStream = KopInteger(getoa(peer,0));
+  portStream = KopInteger(getoa(peer,1));
+
+  if (ipmask.tag != Sinteger) {
+    errorOxmisc2("KoxCreateControl_RFC_101(): ipmask must be an integer.");
+  }
+  if (pass.tag != Sdollar) {
+    errorOxmisc2("KoxCreateControl_RFC_101(): pass must be a string.");
+  }
+
+  client = oxCreateControl_RFC_101(fdStream, portStream,
+                                   KopInteger(ipmask), KopString(pass));
+  if (client == NULL) {
+    errorOxmisc2("KoxCreateControl_RFC_101(): Open error.");
+    return(rob);
+  }
+  rob = newObjectArray(N_OF_CLIENT_FIELDS);
+  oxClientToObject(client,rob);
+  return(rob);
+}
+
+oxclientp oxCreateControl_RFC_101(int fdstream,int portStream,
+                                  int ipmask,char *pass)
+{
+  int v = 0;
+  int fdControl = -1;
+  int fdStream = -1;
+  int m;
+
+  char *s;
+  oxclientp client;
+#if defined(__CYGWIN__)
+  extern sigjmp_buf MyEnv_oxmisc;
+#else
+  extern jmp_buf MyEnv_oxmisc;
+#endif
+  int engineByteOrder;
+  extern int Quiet;
+
+  v = !Quiet;
+  
+  switch(ipmask) {
+  case 0:/* only local */
+    fdStream  = socketAcceptLocal(fdstream);
+    break;
+  default:/* any */
+    fdStream  = socketAccept(fdstream);
+    break;
+  }
+  if (v) fprintf(stderr,"\nControl port %d : Connected.\n",portStream);
+
+  if (fdStream == -1 ) {
+    fprintf(stderr,"\nOpen error in oxCreateControl_RFC_101.\n");
+    return(NULL);
+  }
+
+  /* Authentication by password. */
+  m = strlen(pass);
+  s = (char *)mymalloc(sizeof(char)*(m+1));
+  read(fdStream,s,m+1); s[m] = '\0';
+  if (strcmp(s,pass) != 0) {
+    fprintf(stderr,"oxCreateControl_RFC_101(): password authentication failed for control channel.\n");
+    close(fdStream);
+    return(NULL);
+  }
+
+
+  engineByteOrder = oxSetByteOrder(fdStream);
+  if (v) fprintf(stderr,"Byte order for control stackmacine is %s.\n",
+                 (engineByteOrder == 0? "network byte order":
+                  (engineByteOrder == 1? "little indican":
+                   "big indian")));
+  
+
+  client = (oxclientp) mymalloc(sizeof(oxclient));
+  oxInitClient(client);
+  client->datafp2 = fp2open(fdStream);
+  if (client->datafp2 == NULL) {
+    fprintf(stderr,"oxCreateControl_RFC_101(): fp2open(fd) failed.\n");
+    return(NULL);
+  }
+  client->dataport = portStream;
+  client->controlport = -1;
+  client->controlfd = -1;
+  client->id = oxGetClientID();
+  client->type = CLIENT_SOCKET; /* socket */
+  client->engineByteOrder = engineByteOrder;
+  client->controlByteOrder = -1;
+  return(client);
+}
+
+oxclientp oxCreateEngine_RFC_101(int fdstream,int portStream,
+                                 int ipmask,char *pass, int engineID);
+struct object KoxCreateEngine_RFC_101(struct object peer,struct object ipmask,struct object pass, struct object engineID) 
+{
+  struct object rob = OINIT;
+  oxclientp client;
+  int fdStream, portStream;
+  int i;
+  struct object ob1 = OINIT;
+  rob.tag = Snull;
+  if (peer.tag != Sarray) {
+    errorOxmisc2("KoxCreateEngine_RFC_101(): The first argument must be an array [fdStream, portStream]");
+    return(rob);
+  }
+  if (getoaSize(peer) != 2 ) {
+    errorOxmisc2("KoxCreateEngine_RFC_101(): The first argument must be an array [fdStream, portStream] of size 2.");
+    return(rob);
+  }
+  for (i=0; i<getoaSize(peer); i++) {
+    ob1 = getoa(peer,i);
+    if (ob1.tag != Sinteger) {
+      errorOxmisc2("KoxCreateEngine_RFC_101(): The element of the first argument must be an integer.");
+    }
+  }
+  fdStream = KopInteger(getoa(peer,0));
+  portStream = KopInteger(getoa(peer,1));
+
+  if (ipmask.tag != Sinteger) {
+    errorOxmisc2("KoxCreateEngine_RFC_101(): ipmask must be an integer.");
+  }
+  if (pass.tag != Sdollar) {
+    errorOxmisc2("KoxCreateEngine_RFC_101(): pass must be a string.");
+  }
+  if (engineID.tag != Sinteger) {
+    errorOxmisc2("KoxCreateEngine_RFC_101(): engineID must be an integer.");
+  }
+
+  client = oxCreateEngine_RFC_101(fdStream, portStream,
+                                  KopInteger(ipmask), KopString(pass),KopInteger(engineID));
+  if (client == NULL) {
+    errorOxmisc2("KoxCreateEngine_RFC_101(): Open error.");
+    return(rob);
+  }
+  rob = newObjectArray(N_OF_CLIENT_FIELDS);
+  oxClientToObject(client,rob);
+  oxClientListUpdate(rob);
+  return(rob);
+}
+
+oxclientp oxCreateEngine_RFC_101(int fdstream,int portStream,
+                                 int ipmask,char *pass,int engineID)
+{
+  int v = 0;
+  int fdControl = -1;
+  int fdStream = -1;
+  int m;
+
+  char *s;
+  oxclientp client;
+#if defined(__CYGWIN__)
+  extern sigjmp_buf MyEnv_oxmisc;
+#else
+  extern jmp_buf MyEnv_oxmisc;
+#endif
+  int engineByteOrder;
+  extern int Quiet;
+
+  v = !Quiet;
+  
+  switch(ipmask) {
+  case 0:/* only local */
+    fdStream  = socketAcceptLocal(fdstream);
+    break;
+  default:/* any */
+    fdStream  = socketAccept(fdstream);
+    break;
+  }
+  if (v) fprintf(stderr,"\nEngine port %d : Connected.\n",portStream);
+
+  if (fdStream == -1 ) {
+    fprintf(stderr,"\nOpen error in oxCreateEngine_RFC_101.\n");
+    return(NULL);
+  }
+
+  /* Authentication by password. */
+  /*  skip password check for now. BUG. 
+      m = strlen(pass);
+      s = (char *)mymalloc(sizeof(char)*(m+1));
+      read(fdStream,s,m+1); s[m] = '\0';
+      if (strcmp(s,pass) != 0) {
+      fprintf(stderr,"oxCreateEngine_RFC_101(): password authentication failed for control channel.\n");
+      close(fdStream);
+      return(NULL);
+      }
+  */
+
+  engineByteOrder = oxSetByteOrder(fdStream);
+  if (v) fprintf(stderr,"Byte order for engine stackmacine is %s.\n",
+                 (engineByteOrder == 0? "network byte order":
+                  (engineByteOrder == 1? "little indican":
+                   "big indian")));
+  
+
+  client = (oxclientp) mymalloc(sizeof(oxclient));
+  oxInitClient(client);
+  client->datafp2 = fp2open(fdStream);
+  if (client->datafp2 == NULL) {
+    fprintf(stderr,"oxCreateEngine_RFC_101(): fp2open(fd) failed.\n");
+    return(NULL);
+  }
+  client->dataport = portStream;
+  client->controlport = -1;
+  client->controlfd = -1;
+  client->id = oxGetClientID();
+  client->engineID = engineID;
+  client->type = CLIENT_SOCKET; /* socket */
+  client->engineByteOrder = engineByteOrder;
+  client->controlByteOrder = -1;
+  return(client);
+}
+
+void oxClientListUpdate(struct object ob) {
+  int id;
+  extern struct object OxClientList[];
+  id = KopInteger(getoa(ob,8));
+  /* printf("id=%d\n",id); */
+  if ((id <MAX_N_OF_CLIENT) && (id >= 0)) {
+	OxClientList[id] = ob;
+  }else{
+	errorOxmisc2("oxClientListUpdate(): the client table is full.\n");
+  }
+}
+void oxClientListRemove(struct object ob) {
+  int id;
+  extern struct object OxClientList[];
+  id = KopInteger(getoa(ob,8));
+  if ((id <MAX_N_OF_CLIENT) && (id >= 0)) {
+	(OxClientList[id]).tag = Snull;
+  }else{
+	/* errorOxmisc2("oxClientListRemove(): the client table is full.\n");*/
+  }
+}
+static void KoxCleanClientList() {
+  extern int OxClientListn;
+  extern struct object OxClientList[];
+  int i,j,n;
+  struct object ob = OINIT;
+  n = 0;
+  for (i=0; i<OxClientListn; i++) {
+	if ((OxClientList[i]).tag != Snull) {
+	  if (!isItClientObject(OxClientList[i])) {
+		(OxClientList[i]).tag = Snull;
+	  }
+	}
+  }
+}
+struct object KoxGetClientList() {
+  extern int OxClientListn;
+  extern struct object OxClientList[];
+  int i,j,n;
+  struct object rob = OINIT;
+  KoxCleanClientList();
+  n = 0;
+  for (i=0; i<OxClientListn; i++) {
+	if ((OxClientList[i]).tag != Snull) n++;
+  }
+  rob = newObjectArray(n); 
+  for (i=0, j=0; i<OxClientListn; i++) {
+	if ((OxClientList[i]).tag != Snull) {
+	  if (j >= n) {
+		j=0;
+		errorOxmisc2("oxGetClientList(): the client table is broken.\n");
+	  }
+	  putoa(rob,j,OxClientList[i]);
+	  j++;
+	}
+  }
+  return rob;
+}
+
+