version 1.1, 1999/10/08 02:12:05 |
version 1.26, 2005/07/03 11:08:54 |
|
|
|
/* $OpenXM: OpenXM/src/kan96xx/plugin/oxmisc2.c,v 1.25 2005/06/16 05:07:24 takayama Exp $ */ |
#include <stdio.h> |
#include <stdio.h> |
|
#include <string.h> |
#include "ox_kan.h" |
#include "ox_kan.h" |
#include "oxmisc2.h" /* This file requires sm1 object description. */ |
#include "oxmisc2.h" /* This file requires sm1 object description. */ |
#include "cmo.h" |
#include "cmo.h" |
|
|
extern FILE *MyErrorOut; |
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 SerialOX; /* defined in SerialOX */ |
|
|
extern int OxVersion; |
extern int OxVersion; |
Line 12 int DebugMathCap = 1; |
|
Line 18 int DebugMathCap = 1; |
|
|
|
|
|
int oxGet(oxclientp client, struct object *op,int *isObj) |
int oxGet(oxclientp client, struct object *op,int *isObj) |
/* This method should be synchronized. */ |
/* This method should be synchronized. */ |
/* oxGet is a function for client. */ |
/* oxGet is a function for client. */ |
{ |
{ |
int ans; |
int ans; |
ox_stream os; |
ox_stream os; |
int m; |
int m; |
struct object rob; |
struct object rob = OINIT; |
int sss; /* Serial number of the recieved packet. */ |
int sss; /* Serial number of the recieved packet. */ |
*isObj = 0; |
*isObj = 0; |
op->tag = Snull; |
op->tag = Snull; |
Line 67 int oxGet(oxclientp client, struct object *op,int *isO |
|
Line 73 int oxGet(oxclientp client, struct object *op,int *isO |
|
int oxGetFromControl(oxclientp client) |
int oxGetFromControl(oxclientp client) |
{ |
{ |
int ans = -1; |
int ans = -1; |
|
AbortIfRFC_101(client); |
if (client->cstate != -1) { |
if (client->cstate != -1) { |
ans = oxGetResultOfControlInt32(client->controlfd); |
ans = oxGetResultOfControlInt32(client->controlfd); |
if (ans != -1) { client->cstate = 0; } |
if (ans != -1) { client->cstate = 0; } |
Line 78 int oxGetFromControl(oxclientp client) |
|
Line 85 int oxGetFromControl(oxclientp client) |
|
int oxReq(oxclientp client,int func,struct object ob) |
int oxReq(oxclientp client,int func,struct object ob) |
{ |
{ |
struct object *ob1p; |
struct object *ob1p; |
|
SET_MYERROROUT; |
/* request to the control channel */ |
/* request to the control channel */ |
if (func == SM_control_reset_connection || |
if (func == SM_control_reset_connection || |
func == SM_control_kill) { |
func == SM_control_kill) { |
|
AbortIfRFC_101(client); |
switch(func) { |
switch(func) { |
case SM_control_reset_connection: |
case SM_control_reset_connection: |
oxReqControlResetConnection(client->controlfd); |
oxReqControlResetConnection(client->controlfd); |
client->cstate = 1; |
client->cstate = 0; |
client->dstate = DSTATE_FIRST_SYNC; |
client->dstate = DSTATE_FIRST_SYNC; |
break; |
break; |
case SM_control_kill: |
case SM_control_kill: |
Line 127 int oxReq(oxclientp client,int func,struct object ob) |
|
Line 136 int oxReq(oxclientp client,int func,struct object ob) |
|
break; |
break; |
case SM_setMathCap: |
case SM_setMathCap: |
/* ob = [(mathcap-obj) [[version num, system name] [sm tags] |
/* ob = [(mathcap-obj) [[version num, system name] [sm tags] |
ob1 smtags |
ob1 smtags |
[[ox numbers] [cmo numbers]]] |
oxtags [[ox numbers, [cmo numbers]]] |
ob3 ob2 */ |
ob3 ob2 */ |
|
/* oxtags [[OX_DATA, [cmo numbers]],[OX_DATA_LOCAL,[opt]],...]*/ |
{ |
{ |
struct object ob1; |
struct object ob1 = OINIT; |
struct object ob2; |
struct object ob2 = OINIT; |
struct object ob3; |
struct object ob3 = OINIT; |
struct object smtags; |
struct object obm = OINIT; |
int n,i; |
struct object smtags = OINIT; |
struct mathCap mathcap; |
struct object oxtags = OINIT; |
|
struct object ox = OINIT; |
|
int n,i; |
|
struct mathCap mathcap; |
|
|
if (strcmp(KopString(getoa(ob,0)),"mathcap-object") != 0) { |
if (strcmp(KopString(getoa(ob,0)),"mathcap-object") != 0) { |
errorOxmisc2("data format error in oxReqSetMathCap"); |
errorOxmisc2("data format error in oxReqSetMathCap"); |
client->dstate = DSTATE_ANY; |
client->dstate = DSTATE_ANY; |
break; |
break; |
} |
} |
ob1 = getoa(getoa(ob,1),0); |
obm = getoa(ob,1); |
smtags = getoa(getoa(ob,1),1); |
ob1 = getoa(obm,0); |
ob2 = getoa(getoa(getoa(ob,1),2),1); |
smtags = getoa(obm,1); |
ob3 = getoa(getoa(getoa(ob,1),2),0); |
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 = (struct object *) sGC_malloc(sizeof(struct object)); |
*ob1p = ob1; |
*ob1p = ob1; |
mathcap.infop = ob1p; |
mathcap.infop = ob1p; |
n = getoaSize(ob2); |
|
mathcap.n = n; |
n = getoaSize(oxtags); |
if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer."); |
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; |
mathcap.oxSize = n; |
for (i=0; i<n; i++) { |
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); |
n = getoaSize(smtags); |
if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer."); |
if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer."); |
mathcap.smSize = n; |
mathcap.smSize = n; |
for (i=0; i<n; i++) { |
for (i=0; i<n; i++) { |
mathcap.sm[i] = KopInteger(getoa(smtags,i)); |
mathcap.sm[i] = KopInteger(getoa(smtags,i)); |
} |
} |
|
|
oxReqSetMathCap(client->datafp2,&mathcap); |
oxReqSetMathCap(client->datafp2,&mathcap); |
Line 199 int oxReq(oxclientp client,int func,struct object ob) |
|
Line 227 int oxReq(oxclientp client,int func,struct object ob) |
|
oxReqExecuteFunction(client->datafp2,KopString(ob)); |
oxReqExecuteFunction(client->datafp2,KopString(ob)); |
client->dstate = DSTATE_ANY; |
client->dstate = DSTATE_ANY; |
break; |
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: |
case SM_popString: |
oxReqPopString(client->datafp2); |
oxReqPopString(client->datafp2); |
client->dstate = DSTATE_ANY; |
client->dstate = DSTATE_ANY; |
Line 227 int oxReq(oxclientp client,int func,struct object ob) |
|
Line 263 int oxReq(oxclientp client,int func,struct object ob) |
|
oxReqSingleOperand(client->datafp2,SM_dupErrors); |
oxReqSingleOperand(client->datafp2,SM_dupErrors); |
client->dstate = DSTATE_ANY; |
client->dstate = DSTATE_ANY; |
break; |
break; |
|
case SM_pushCMOtag: |
|
oxReqSingleOperand(client->datafp2,SM_pushCMOtag); |
|
client->dstate = DSTATE_ANY; |
|
break; |
default: |
default: |
fprintf(MyErrorOut,"func=%d ",func); |
fprintf(MyErrorOut,"func=%d ",func); |
errorOxmisc2("This function is not implemented."); |
errorOxmisc2("This function is not implemented."); |
Line 237 int oxReq(oxclientp client,int func,struct object ob) |
|
Line 277 int oxReq(oxclientp client,int func,struct object ob) |
|
} |
} |
|
|
struct object KoxCreateClient(struct object ip, |
struct object KoxCreateClient(struct object ip, |
struct object portStream, |
struct object portStream, |
struct object portControl) |
struct object portControl,struct object pass) |
{ |
{ |
struct object rob; |
struct object rob = OINIT; |
oxclientp client; |
oxclientp client; |
|
char *passControl; char *passData; |
|
struct object tob = OINIT; |
|
passControl = NULL; passData = NULL; |
rob.tag = Snull; |
rob.tag = Snull; |
if (ip.tag != Sdollar) { |
if (ip.tag != Sdollar) { |
errorOxmisc2("KoxCreateClient(): The first argument must be a hostname given by a string."); |
errorOxmisc2("KoxCreateClient(): The first argument must be a hostname given by a string."); |
Line 249 struct object KoxCreateClient(struct object ip, |
|
Line 292 struct object KoxCreateClient(struct object ip, |
|
} |
} |
if (portStream.tag == Sdollar) { |
if (portStream.tag == Sdollar) { |
client = oxCreateClientFile(KopString(ip),KopString(portStream), |
client = oxCreateClientFile(KopString(ip),KopString(portStream), |
"/dev/null","w"); |
"/dev/null","w"); |
if (client == NULL) { |
if (client == NULL) { |
errorOxmisc2("KoxCreateClient(): Open error."); |
errorOxmisc2("KoxCreateClient(): Open error."); |
return(rob); |
return(rob); |
Line 267 struct object KoxCreateClient(struct object ip, |
|
Line 310 struct object KoxCreateClient(struct object ip, |
|
errorOxmisc2("KoxCreateClient(): The third argument must be a port number given in an integer."); |
errorOxmisc2("KoxCreateClient(): The third argument must be a port number given in an integer."); |
return(rob); |
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) { |
if (client == NULL) { |
errorOxmisc2("KoxCreateClient(): Open error."); |
errorOxmisc2("KoxCreateClient(): Open error."); |
return(rob); |
return(rob); |
} |
} |
rob = newObjectArray(N_OF_CLIENT_FIELDS); |
rob = newObjectArray(N_OF_CLIENT_FIELDS); |
oxClientToObject(client,rob); |
oxClientToObject(client,rob); |
|
oxClientListUpdate(rob); |
return(rob); |
return(rob); |
} |
} |
|
|
Line 305 static int isItClientObject(struct object ob) |
|
Line 367 static int isItClientObject(struct object ob) |
|
|
|
struct object KoxIsThereErrorClient(struct object ob) |
struct object KoxIsThereErrorClient(struct object ob) |
{ |
{ |
struct object rob; |
struct object rob = OINIT; |
int ans; |
int ans; |
int size; |
int size; |
oxclient cc; |
oxclient cc; |
Line 321 struct object KoxIsThereErrorClient(struct object ob) |
|
Line 383 struct object KoxIsThereErrorClient(struct object ob) |
|
|
|
int oxClientToObject(oxclientp client,struct object rob) |
int oxClientToObject(oxclientp client,struct object rob) |
{ |
{ |
struct object ob; |
struct object ob = OINIT; |
if (client == NULL) return; |
if (client == NULL) return; |
/* rob = newObjectArray(N_OF_CLIENT_FIELDS); */ |
/* rob = newObjectArray(N_OF_CLIENT_FIELDS); */ |
if (rob.tag != Sarray) { |
if (rob.tag != Sarray) { |
Line 354 int oxClientToObject(oxclientp client,struct object ro |
|
Line 416 int oxClientToObject(oxclientp client,struct object ro |
|
} |
} |
putoa(rob,11,KpoInteger(client->engineByteOrder)); |
putoa(rob,11,KpoInteger(client->engineByteOrder)); |
putoa(rob,12,KpoInteger(client->controlByteOrder)); |
putoa(rob,12,KpoInteger(client->controlByteOrder)); |
|
putoa(rob,13,KpoInteger(client->engineID)); |
return(0); |
return(0); |
} |
} |
|
|
int oxObjectToClient(struct object ob,oxclientp cp) |
int oxObjectToClient(struct object ob,oxclientp cp) |
{ |
{ |
struct object ob1; |
struct object ob1 = OINIT; |
struct object *obp; |
struct object *obp; |
if (cp == NULL) { |
if (cp == NULL) { |
errorOxmisc2("oxObjectToClient(): the second argument is NULL"); |
errorOxmisc2("oxObjectToClient(): the second argument is NULL"); |
Line 410 int oxObjectToClient(struct object ob,oxclientp cp) |
|
Line 473 int oxObjectToClient(struct object ob,oxclientp cp) |
|
cp->engineByteOrder = KopInteger(ob1); |
cp->engineByteOrder = KopInteger(ob1); |
ob1 = getoa(ob,12); |
ob1 = getoa(ob,12); |
cp->controlByteOrder = KopInteger(ob1); |
cp->controlByteOrder = KopInteger(ob1); |
|
|
|
ob1 = getoa(ob,13); |
|
cp->engineID = KopInteger(ob1); |
|
|
|
|
return(0); |
return(0); |
} |
} |
|
|
struct object KoxReq(struct object client, |
struct object KoxReq(struct object client, |
struct object func, |
struct object func, |
struct object ob1) |
struct object ob1) |
{ |
{ |
int ans; |
int ans; |
static oxclientp cc1 = NULL; |
static oxclientp cc1 = NULL; |
struct object rob; |
struct object rob = OINIT; |
rob.tag = Snull; |
rob.tag = Snull; |
if (cc1 == NULL) { |
if (cc1 == NULL) { |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
Line 452 struct object KoxGet(struct object client) |
|
Line 518 struct object KoxGet(struct object client) |
|
{ |
{ |
int ans,k; |
int ans,k; |
static oxclientp cc1 = NULL; |
static oxclientp cc1 = NULL; |
struct object rob; |
struct object rob = OINIT; |
rob.tag = Snull; |
rob.tag = Snull; |
if (cc1 == NULL) { |
if (cc1 == NULL) { |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
Line 483 struct object KoxGetFromControl(struct object client) |
|
Line 549 struct object KoxGetFromControl(struct object client) |
|
{ |
{ |
int ans; |
int ans; |
static oxclientp cc1 = NULL; |
static oxclientp cc1 = NULL; |
struct object rob; |
struct object rob = OINIT; |
rob.tag = Snull; |
rob.tag = Snull; |
if (cc1 == NULL) { |
if (cc1 == NULL) { |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
Line 513 struct object KoxMultiSelect(struct object oclients,st |
|
Line 579 struct object KoxMultiSelect(struct object oclients,st |
|
static int csize = 0; |
static int csize = 0; |
static oxclientp *clients = NULL; |
static oxclientp *clients = NULL; |
oxclientp cc1; |
oxclientp cc1; |
struct object rob; |
struct object rob = OINIT; |
int i; |
int i; |
int tt; |
int tt; |
struct object ob1; |
struct object ob1 = OINIT; |
struct object ob2; |
struct object ob2 = OINIT; |
struct object ob0; |
struct object ob0 = OINIT; |
int size; |
int size; |
int ans; |
int ans; |
int dataready[1024]; |
int dataready[1024]; |
Line 533 struct object KoxMultiSelect(struct object oclients,st |
|
Line 599 struct object KoxMultiSelect(struct object oclients,st |
|
if (first) { |
if (first) { |
first = 0; csize = size; |
first = 0; csize = size; |
clients = (oxclientp *)mymalloc(sizeof(oxclientp)*(size+1)); |
clients = (oxclientp *)mymalloc(sizeof(oxclientp)*(size+1)); |
if (clients == NULL) { |
if (clients == NULL) { |
errorOxmisc2("KoxMultiSelect(): no more memory."); |
errorOxmisc2("KoxMultiSelect(): no more memory."); |
return(rob); |
return(rob); |
} |
} |
for (i=0; i<size; i++) { |
for (i=0; i<size; i++) { |
clients[i] = (oxclientp) mymalloc(sizeof(oxclient)); |
clients[i] = (oxclientp) mymalloc(sizeof(oxclient)); |
if (clients[i] == NULL) { |
if (clients[i] == NULL) { |
errorOxmisc2("KoxMultiSelect(): no more memory."); |
errorOxmisc2("KoxMultiSelect(): no more memory."); |
return(rob); |
return(rob); |
} |
} |
oxInitClient(clients[i]); |
oxInitClient(clients[i]); |
} |
} |
Line 579 struct object KoxMultiSelect(struct object oclients,st |
|
Line 645 struct object KoxMultiSelect(struct object oclients,st |
|
} |
} |
|
|
struct object KoxWatch(struct object client,struct object f) |
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; |
int ans,k; |
static oxclientp cc1 = NULL; |
static oxclientp cc1 = NULL; |
struct object rob; |
struct object rob = OINIT; |
|
extern int WatchStream; |
rob.tag = Snull; |
rob.tag = Snull; |
|
if (client.tag == Sinteger) { |
|
if (KopInteger(client)) { |
|
WatchStream = 1; |
|
}else{ |
|
WatchStream = 0; |
|
} |
|
return; |
|
} |
if (cc1 == NULL) { |
if (cc1 == NULL) { |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
cc1 = (oxclientp) mymalloc(sizeof(oxclient)); |
if (cc1 == NULL) { |
if (cc1 == NULL) { |
Line 607 struct object KoxWatch(struct object client,struct obj |
|
Line 682 struct object KoxWatch(struct object client,struct obj |
|
return(KpoInteger(ans)); |
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) { |
struct object KoxCloseClient(struct object client) { |
oxclientp cc1 = NULL; |
oxclientp cc1 = NULL; |
oxclient cc; |
oxclient cc; |
struct object rob; |
struct object rob = OINIT; |
rob.tag = Snull; |
rob.tag = Snull; |
cc1 = &cc; |
cc1 = &cc; |
if (oxObjectToClient(client,cc1) == -1) return(rob); |
if (oxObjectToClient(client,cc1) == -1) return(rob); |
Line 638 struct object KoxCloseClient(struct object client) { |
|
Line 770 struct object KoxCloseClient(struct object client) { |
|
errorOxmisc2("Unknown client->type\n"); |
errorOxmisc2("Unknown client->type\n"); |
break; |
break; |
} |
} |
|
oxClientListRemove(client); |
return(KpoInteger(0)); |
return(KpoInteger(0)); |
|
|
} |
} |
Line 648 static int cmoCheck00(struct object obj,int cmo[], int |
|
Line 781 static int cmoCheck00(struct object obj,int cmo[], int |
|
#define CHECK00_N 4098 /* look up stackm.h and kclass.h */ |
#define CHECK00_N 4098 /* look up stackm.h and kclass.h */ |
static int typeTrans[CHECK00_N]; |
static int typeTrans[CHECK00_N]; |
static int init = 0; |
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) { |
if (!init) { |
for (i=0; i<CHECK00_N; i++) { |
for (i=0; i<CHECK00_N; i++) { |
typeTrans[i] = 0; /* unknown cmo number */ |
typeTrans[i] = 0; /* unknown cmo number */ |
Line 665 static int cmoCheck00(struct object obj,int cmo[], int |
|
Line 800 static int cmoCheck00(struct object obj,int cmo[], int |
|
/* typeTrans[Spoly] = CMO_DMS; */ |
/* typeTrans[Spoly] = CMO_DMS; */ |
typeTrans[Spoly] = CMO_DISTRIBUTED_POLYNOMIAL; |
typeTrans[Spoly] = CMO_DISTRIBUTED_POLYNOMIAL; |
typeTrans[Sdouble] = CMO_64BIT_MACHINE_DOUBLE; |
typeTrans[Sdouble] = CMO_64BIT_MACHINE_DOUBLE; |
|
typeTrans[SrationalFunction] = CMO_RATIONAL; |
typeTrans[CLASSNAME_ERROR_PACKET] = CMO_ERROR2; |
typeTrans[CLASSNAME_ERROR_PACKET] = CMO_ERROR2; |
typeTrans[CLASSNAME_mathcap] = CMO_MATHCAP; |
typeTrans[CLASSNAME_mathcap] = CMO_MATHCAP; |
typeTrans[CLASSNAME_indeterminate] = CMO_INDETERMINATE; |
typeTrans[CLASSNAME_indeterminate] = CMO_INDETERMINATE; |
Line 677 static int cmoCheck00(struct object obj,int cmo[], int |
|
Line 813 static int cmoCheck00(struct object obj,int cmo[], int |
|
if (obj.tag == Sclass) { |
if (obj.tag == Sclass) { |
ttt = typeTrans[ectag(obj)]; |
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++) { |
for (i=0; i<n; i++) { |
if (ttt == cmo[i]) { |
if (ttt == cmo[i]) { |
if (ttt != CMO_LIST) return(1); |
if (ttt != CMO_LIST) return(1); |
else { |
else { |
m = getoaSize(obj); |
m = getoaSize(obj); |
for (j=0; j<m; j++) { |
for (j=0; j<m; j++) { |
if (!cmoCheck00(getoa(obj,j),cmo,n)) return(0); |
if (!cmoCheck00(getoa(obj,j),cmo,n)) return(0); |
} |
} |
return(1); |
return(1); |
} |
} |
} |
} |
} |
} |
Line 694 static int cmoCheck00(struct object obj,int cmo[], int |
|
Line 835 static int cmoCheck00(struct object obj,int cmo[], int |
|
if (DebugMathCap && 1) { |
if (DebugMathCap && 1) { |
fprintf(stderr,"Type translation table (internal object tag --> CMO tag)\n"); |
fprintf(stderr,"Type translation table (internal object tag --> CMO tag)\n"); |
for (i=0; i<20; i++) { |
for (i=0; i<20; i++) { |
printf("%d ", typeTrans[i]); |
printf("%d ", typeTrans[i]); |
} |
} |
printf("\n"); |
printf("\n"); |
} |
} |
Line 711 static int cmoCheck00(struct object obj,int cmo[], int |
|
Line 852 static int cmoCheck00(struct object obj,int cmo[], int |
|
|
|
int cmoCheckMathCap(struct object obj, struct object *obp) |
int cmoCheckMathCap(struct object obj, struct object *obp) |
{ |
{ |
struct object mathcap; |
struct object mathcap = OINIT; |
struct object cmolist; |
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 n; |
int i; |
int i; |
#define CMO_CHECK_MATH_CAP_LIST_SIZE 1024 |
#define CMO_CHECK_MATH_CAP_LIST_SIZE 1024 |
int cmo[CMO_CHECK_MATH_CAP_LIST_SIZE]; |
int cmo[CMO_CHECK_MATH_CAP_LIST_SIZE]; |
if (obp == NULL) return(1); |
if (obp == NULL) return(1); |
|
/* printObject(*obp,0,stderr); for debug*/ |
if (obp->tag != Sarray) { |
if (obp->tag != Sarray) { |
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
printObject(*obp,0,stderr); |
printObject(*obp,0,stderr); |
Line 725 int cmoCheckMathCap(struct object obj, struct object * |
|
Line 873 int cmoCheckMathCap(struct object obj, struct object * |
|
errorOxmisc2("cmoCheckMathCap: format error in the client->mathcapObjp field.\n"); |
errorOxmisc2("cmoCheckMathCap: format error in the client->mathcapObjp field.\n"); |
} |
} |
mathcap = *obp; |
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); |
n = getoaSize(mathcap); |
if (n < 2) { |
if (n < 2) { |
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
Line 732 int cmoCheckMathCap(struct object obj, struct object * |
|
Line 889 int cmoCheckMathCap(struct object obj, struct object * |
|
fprintf(stderr,"\n"); |
fprintf(stderr,"\n"); |
errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n"); |
errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n"); |
} |
} |
/* I should check |
ob0 = getoa(mathcap,0); |
getoa(getoa(mathcap,2),0) |
if (ob0.tag != Sdollar) { |
contains OX_DATA. |
|
It has not yet implemented. |
|
*/ |
|
mathcap = getoa(getoa(mathcap,1),2); |
|
n = getoaSize(mathcap); |
|
if (n < 2) { |
|
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
printObject(*obp,0,stderr); |
printObject(*obp,0,stderr); |
fprintf(stderr,"\n"); |
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 (strcmp(KopString(ob0),"mathcap-object") != 0) { |
if (cmolist.tag != Sarray) { |
|
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n"); |
printObject(*obp,0,stderr); |
printObject(*obp,0,stderr); |
fprintf(stderr,"\n"); |
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) { |
/* I should check |
errorOxmisc2("cmoCheckMathCap: Too big cmo list.\n"); |
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++) { |
if (getoaSize(mathcapMain) < 3) { |
cmo[i] = KopInteger(getoa(cmolist,i)); |
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)); |
return(cmoCheck00(obj,cmo,n)); |
} |
} |
|
|
|
|
struct object KoxGenPortFile(void) { |
struct object KoxGenPortFile(void) { |
struct object ob; |
struct object ob = OINIT; |
ob = KpoString(oxGenPortFile()); |
ob = KpoString(oxGenPortFile()); |
return(ob); |
return(ob); |
} |
} |
Line 774 void KoxRemovePortFile(void) { |
|
Line 980 void KoxRemovePortFile(void) { |
|
|
|
void oxPushMathCap(struct mathCap *mathcap) |
void oxPushMathCap(struct mathCap *mathcap) |
{ |
{ |
struct object rob; |
struct object rob = OINIT; |
rob = newMathCap(mathcap); |
rob = newMathCap(mathcap); |
Kpush(rob); |
Kpush(rob); |
} |
} |
|
|
struct object KoxGenPass(void) { |
struct object KoxGenPass(void) { |
struct object rob; |
struct object rob = OINIT; |
rob = KpoString(oxGenPass()); |
rob = KpoString(oxGenPass()); |
return(rob); |
return(rob); |
} |
} |
|
|
struct object KoxGetPort(struct object host) |
struct object KoxGetPort(struct object host) |
{ |
{ |
struct object rob; |
struct object rob = OINIT; |
int fdStream, fdControl; |
int fdStream, fdControl; |
int portStream, portControl; |
int portStream, portControl; |
extern int OpenedSocket; |
extern int OpenedSocket; |
Line 809 struct object KoxGetPort(struct object host) |
|
Line 1015 struct object KoxGetPort(struct object host) |
|
putoa(rob,3,KpoInteger(portControl)); |
putoa(rob,3,KpoInteger(portControl)); |
return(rob); |
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 KoxCreateClient2(struct object peer, |
struct object ipmask, |
struct object ipmask, |
struct object pass) |
struct object pass) |
{ |
{ |
struct object rob; |
struct object rob = OINIT; |
oxclientp client; |
oxclientp client; |
int fdStream, portStream, fdControl, portControl; |
int fdStream, portStream, fdControl, portControl; |
int i; |
int i; |
struct object ob1; |
struct object ob1 = OINIT; |
|
struct object opassControl = OINIT; |
|
struct object opassData = OINIT; |
rob.tag = Snull; |
rob.tag = Snull; |
if (peer.tag != Sarray) { |
if (peer.tag != Sarray) { |
errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl]"); |
errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl]"); |
Line 842 struct object KoxCreateClient2(struct object peer, |
|
Line 1070 struct object KoxCreateClient2(struct object peer, |
|
if (ipmask.tag != Sinteger) { |
if (ipmask.tag != Sinteger) { |
errorOxmisc2("KoxCreateClient2(): ipmask must be an integer."); |
errorOxmisc2("KoxCreateClient2(): ipmask must be an integer."); |
} |
} |
if (pass.tag != Sdollar) { |
if (pass.tag == Sdollar) { |
errorOxmisc2("KoxCreateClient2(): pass must be a string."); |
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, |
client = oxCreateClient2(fdStream, portStream, fdControl, portControl, |
KopInteger(ipmask), KopString(pass)); |
KopInteger(ipmask), |
|
KopString(opassControl),KopString(opassData)); |
if (client == NULL) { |
if (client == NULL) { |
errorOxmisc2("KoxCreateClient2(): Open error."); |
errorOxmisc2("KoxCreateClient2(): Open error."); |
return(rob); |
return(rob); |
} |
} |
rob = newObjectArray(N_OF_CLIENT_FIELDS); |
rob = newObjectArray(N_OF_CLIENT_FIELDS); |
oxClientToObject(client,rob); |
oxClientToObject(client,rob); |
|
oxClientListUpdate(rob); |
return(rob); |
return(rob); |
} |
} |
|
|
|
int KgetCmoTagOfObject(struct object obj) { |
|
int k; |
|
k=cmoCheck00(obj,(int *)NULL,0); |
|
return(k); |
|
} |
|
|
errorOxmisc2(char *s) { |
errorOxmisc2(char *s) { |
|
SET_MYERROROUT; |
fprintf(MyErrorOut,"error in oxmisc2.c: %s\n",s); |
fprintf(MyErrorOut,"error in oxmisc2.c: %s\n",s); |
errorKan1("%s\n"," "); |
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; |
|
} |
|
|
|
|