Annotation of OpenXM/src/kxx/oxserver00.c, Revision 1.17
1.17 ! takayama 1: /* $OpenXM: OpenXM/src/kxx/oxserver00.c,v 1.16 2004/09/17 02:42:58 takayama Exp $ */
1.1 maekawa 2: /* nullserver01 */
3: #include <stdio.h>
4: #include <sys/types.h>
5: #include <sys/socket.h>
6: #include <sys/time.h>
7: #include <netinet/in.h>
8: #include <netdb.h>
9: #include <signal.h>
10: #include <setjmp.h>
11: /* -lnsl -lsocket /usr/ucblib/libucb.a */
12: #include "ox_kan.h"
13: #include "serversm.h"
14:
15: int OxCritical = 0;
16: int OxInterruptFlag = 0;
17: int PacketMonitor = 0;
1.13 takayama 18: int NoExecution = 0;
1.1 maekawa 19:
20: extern int SerialOX; /* Serial number of the packets sent. */
21: extern int SerialCurrent; /* Current Serial number of the recieved packet. */
22: extern int OXprintMessage; /* print oxmessages? */
1.15 takayama 23: extern int Calling_ctrlC_hook;
1.16 takayama 24: extern int RestrictedMode, RestrictedMode_saved;
1.1 maekawa 25:
1.7 takayama 26: #if defined(__CYGWIN__)
27: sigjmp_buf EnvOfChildServer;
28: #else
1.1 maekawa 29: jmp_buf EnvOfChildServer;
1.7 takayama 30: #endif
1.1 maekawa 31:
32: int JmpMessage = 0;
1.12 takayama 33: extern int Lisplike;
1.1 maekawa 34:
35: static char *getSuffix(char *s);
36: main(int argc, char *argv[]) {
37: char *s;
38: char *forAsir[] = {"callsm1.sm1","callsm1b.sm1"};
39: char *gnuplot[] = {"callsm1.sm1","gnuplot.sm1"};
40: char *phc[] = {"callsm1.sm1","phc.sm1"};
41: char *tigers[] = {"callsm1.sm1","tigers.sm1"};
42: char *basicCD[] = {"basicCD.sm1"};
43: /* If you change the above, you need to change the argc of Sm1_start below.
1.5 takayama 44: */
1.1 maekawa 45:
46: if (argc > 1) {
47: if (strcmp(argv[1],"-monitor")==0) {
48: fprintf(stderr,"Taking the packet monitor.\n");
49: PacketMonitor = 1;
1.12 takayama 50: }else if (strcmp(argv[1],"-lispLike")==0) {
51: fprintf(stderr,"Output lispLike expression.\n");
52: Lisplike = 1;
1.13 takayama 53: }else if (strcmp(argv[1],"-noexec")==0) {
54: fprintf(stderr,"I do not execute commands.\n");
55: NoExecution = 1;
1.1 maekawa 56: }else{
57: fprintf(stderr,"Unknown option. Possible options are -monitor\n");
58: }
59: }
60: /* Load initialization files if necessary. */
61: s = getSuffix(argv[0]);
62: if (strcmp(s,"forAsir") == 0) {
63: Sm1_start(2,forAsir,"ox_sm1_forAsir");
64: }else if (strcmp(s,"gnuplot") == 0) {
65: Sm1_start(2,gnuplot,"ox_sm1_gnuplot");
66: }else if (strcmp(s,"phc") == 0) {
67: Sm1_start(2,phc,"ox_sm1_phc");
68: }else if (strcmp(s,"tigers") == 0) {
69: Sm1_start(2,tigers,"ox_sm1_tigers");
70: }else if (strcmp(s,"basicCD") == 0) {
71: Sm1_start(1,basicCD,"basicCD");
72: }else { /* Default */
73: Sm1_start(0, NULL, "ox_sm1");
74: }
75:
1.11 takayama 76: nullserver(3,4);
1.1 maekawa 77: }
78:
79: static char *getSuffix(char *s) {
80: /* getSuffix("ox_sm1_forAsir") returns "forAsir" */
1.6 takayama 81: /* getSuffix("ox_sm1_forAsir.exe") returns "forAsir" */
1.1 maekawa 82: /* getSuffix("ox_sm1_gnuplot") returns "gnuplot" */
83: int n,i,k;
84: n = strlen(s);
1.6 takayama 85: if (n > 5 && (strcmp(".exe",&(s[n-4]))==0 || strcmp(".EXE",&(s[n-4]))==0)) {
86: s[n-4] = '\0';
87: }
1.1 maekawa 88: for (i=n-1; i>=0; i--) {
89: if (s[i] == '_') {
90: return( s+i+1 );
91: }
92: }
93: return(s);
94: }
1.11 takayama 95: nullserver(int fdStreamIn,int fdStreamOut) {
1.1 maekawa 96: int mtag;
97: int message = 1;
1.11 takayama 98: ox_stream ostreamIn;
99: ox_stream ostreamOut;
1.1 maekawa 100: char sreason[1024];
101: extern void controlResetHandler();
1.7 takayama 102: #if defined(__CYGWIN__)
103: extern sigjmp_buf EnvOfStackMachine;
104: #else
1.1 maekawa 105: extern jmp_buf EnvOfStackMachine;
1.7 takayama 106: #endif
1.1 maekawa 107: int engineByteOrder;
108:
1.12 takayama 109: /* for debug, use -monitor
110: PacketMonitor = 1; */
1.11 takayama 111:
1.4 takayama 112: fflush(NULL);
1.11 takayama 113: engineByteOrder = oxTellMyByteOrder(fdStreamOut,fdStreamIn);
1.1 maekawa 114: /* Set the network byte order. */
115: fprintf(stderr,"engineByteOrder=%x\n",engineByteOrder);
116:
1.11 takayama 117: if (fdStreamIn != -1) {
118: ostreamIn = fp2open(fdStreamIn);
119: if (ostreamIn == NULL) {
120: fprintf(stderr,"fp2open(fdStreamIn) failed.\n");
121: fdStreamIn = -1;
122: }
123: if (PacketMonitor) fp2watch(ostreamIn,stdout);
124: }
125: if (fdStreamOut != -1) {
126: ostreamOut = fp2open(fdStreamOut);
127: if (ostreamOut == NULL) {
128: fprintf(stderr,"fp2open(fdStreamOut) failed.\n");
129: fdStreamOut = -1;
1.1 maekawa 130: }
1.11 takayama 131: if (PacketMonitor) fp2watch(ostreamOut,stdout);
1.1 maekawa 132: }
1.11 takayama 133:
1.1 maekawa 134: aaa : ;
1.7 takayama 135: #if defined(__CYGWIN__)
136: if (sigsetjmp(EnvOfChildServer,1)) {
137: #else
1.1 maekawa 138: if (setjmp(EnvOfChildServer)) {
1.7 takayama 139: #endif
1.1 maekawa 140: fprintf(stderr,"childServerMain: jump here.\n");
141: if (OxInterruptFlag == 0) {
142: fprintf(stderr," ?! \n"); fflush(NULL);
143: }
1.15 takayama 144: if (!Calling_ctrlC_hook) {
1.16 takayama 145: Calling_ctrlC_hook = 1; RestrictedMode = 0;
1.15 takayama 146: KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
1.16 takayama 147: RestrictedMode = RestrictedMode_saved;
1.15 takayama 148: }
149: Calling_ctrlC_hook = 0;
1.9 takayama 150: KSexecuteString(" (Computation is interrupted.) ");
1.1 maekawa 151: signal(SIGUSR1,controlResetHandler); goto aaa;
152: } else {
153: if (JmpMessage) fprintf(stderr,"Set EnvOfChildServer.\n");
154: signal(SIGUSR1,controlResetHandler);
155: }
1.7 takayama 156: #if defined(__CYGWIN__)
157: if (sigsetjmp(EnvOfStackMachine,1)) {
158: #else
1.1 maekawa 159: if (setjmp(EnvOfStackMachine)) {
1.7 takayama 160: #endif
1.9 takayama 161: fprintf(stderr,"childServerMain: jump here by EnvOfStackMachine or timeout.\n");
1.1 maekawa 162: if (OxInterruptFlag == 0) {
163: fprintf(stderr," ?! \n"); fflush(NULL);
164: }
165: /* In case of error in the stack machine, pop the error info
166: and send the error packet. */
167: /* oxSendOXheader(ostream,OX_DATA,SerialOX++);
1.5 takayama 168: oxSendCmoError(ostream);
169: oxSendOXheader(ostream,OX_DATA,SerialOX++);
170: sprintf(sreason,"Jump here by sm1 error.");
171: oxSendCmoError2(ostream,sreason);
1.1 maekawa 172: */
173: Sm1_pushError2(SerialCurrent,-1,"Global jump by sm1 error");
174:
1.15 takayama 175: if (!Calling_ctrlC_hook) {
1.16 takayama 176: Calling_ctrlC_hook = 1; RestrictedMode = 0;
1.15 takayama 177: KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
1.16 takayama 178: RestrictedMode = RestrictedMode_saved;
1.15 takayama 179: }
180: Calling_ctrlC_hook = 0;
1.1 maekawa 181: signal(SIGUSR1,controlResetHandler); goto aaa ;
182: } else {
183: if (JmpMessage) fprintf(stderr,"Set EnvOfStackMachine.\n");
184: if (signal(SIGUSR1,SIG_IGN) != SIG_IGN) {
185: signal(SIGUSR1,controlResetHandler);
186: }
187: }
188:
189: while (1) {
1.11 takayama 190: message = OXprintMessage;
1.1 maekawa 191: if (OxInterruptFlag) {
192: OxCritical = 1;
193: if (message) {fprintf(stderr,"Clearing the read buffer.\n");fflush(NULL); }
1.11 takayama 194: fp2clearReadBuf(ostreamIn); /* clear the read buffer */
1.1 maekawa 195: if (message) {fprintf(stderr,"Throwing OX_SYNC_BALL\n"); fflush(NULL);}
1.11 takayama 196: oxSendSyncBall(ostreamOut);
1.1 maekawa 197: if (message) {fprintf(stderr,"Waiting for OX_SYNC_BALL\n");fflush(NULL);}
1.11 takayama 198: oxWaitSyncBall(ostreamIn);
1.1 maekawa 199: if (message) {fprintf(stderr,"Done changing OX_SYNC_BALL\n"); fflush(NULL);}
200: OxInterruptFlag = 0;
201: OxCritical = 0;
202: goto aaa ;
203: }
204: OxCritical = 0;
1.11 takayama 205: if (fp2select(ostreamIn,-1)) {
1.1 maekawa 206: /* If there is an data in the ostream, then read data in the buffer and
207: read data in the communication stream. */
208: OxCritical = 1;
209: }else{
210: /* interrupted system call */
211: /* This part is never reached. */
212: }
213: OxCritical = 1;
1.11 takayama 214: mtag = oxGetOXheader(ostreamIn,&SerialCurrent); /* get the message_tag */
1.1 maekawa 215: if (message) {
216: fprintf(stderr,"\nmtag is %d (serial=%d) : ",mtag,SerialCurrent);
217: switch(mtag) {
218: case OX_COMMAND: fprintf(stderr," OX_COMMAND \n"); break;
219: case OX_DATA: fprintf(stderr," OX_DATA \n"); break;
220: case OX_SYNC_BALL: fprintf(stderr," OX_SYNC_BALL \n"); break;
221: case -1: fprintf(stderr," End of file. Exiting the server child.\n");
1.10 ohara 222: exit(0); break;
1.1 maekawa 223: default: fprintf(stderr," ?! \n"); break;
224: }
225: }
226: /*sleep(2); /* for dubug OX_SYNC_BALL */
227: switch(mtag) {
228: case OX_COMMAND:
1.11 takayama 229: nullserverCommand(ostreamIn,ostreamOut);
1.1 maekawa 230: goto aaa ; /* We always reset the jump vector. cf. memo1.txt 1998 2/13*/
231: break;
232: case OX_DATA:
1.11 takayama 233: Sm1_pushCMO(ostreamIn);
1.1 maekawa 234: break;
235: case OX_SYNC_BALL:
236: /* if (OxInterruptFlag) think about it later. */
237: break;
238: default:
239: fprintf(stderr,"Fatal error in server.\n");
240: break;
241: }
242: }
243: }
244:
1.11 takayama 245: nullserverCommand(ox_stream ostreamIn,ox_stream ostreamOut) {
1.1 maekawa 246: int id;
247: int mtag;
248: int n;
249: char *name;
250: char *sresult;
251: struct mathCap *mathresult;
252: int iresult;
253: int message = 1;
254: char *emsg;
255: extern void controlResetHandler();
256:
1.11 takayama 257: message = OXprintMessage;
1.1 maekawa 258: /* message_body */
1.11 takayama 259: id = oxGetInt32(ostreamIn); /* get the function_id */
1.12 takayama 260: if (message) {fprintf(stderr,"\nfunction_id is %d; %s\n",id,oxFIDtoStr(id));}
1.1 maekawa 261: switch( id ) {
262: case SM_mathcap:
263: mathresult = (struct mathCap *)Sm1_mathcap();
264: oxPushMathCap(mathresult);
265: break;
266: case SM_setMathCap:
1.11 takayama 267: Sm1_setMathCap(ostreamOut);
1.1 maekawa 268: break;
269: case SM_pops:
270: Sm1_pops();
271: break;
272: case SM_getsp:
273: Sm1_getsp();
274: break;
275: case SM_dupErrors:
276: Sm1_dupErrors();
277: break;
1.3 takayama 278: case SM_pushCMOtag:
279: Sm1_pushCMOtag(SerialCurrent);
1.5 takayama 280: break;
1.1 maekawa 281: case SM_setName:
282: iresult = Sm1_setName();
283: if (iresult < 0) {
284: Sm1_pushError2(SerialCurrent,-1,"setName");
285: }
286: break;
287: case SM_evalName:
288: iresult = Sm1_evalName();
289: if (iresult < 0) {
290: Sm1_pushError2(SerialCurrent,-1,"evalName");
291: }
292: break;
293: case SM_executeStringByLocalParser:
294: OxCritical = 0;
1.13 takayama 295: if (NoExecution) {
296: iresult = 0;
297: }else{
298: iresult = Sm1_executeStringByLocalParser();
299: }
1.1 maekawa 300: OxCritical = 1; signal(SIGUSR1,controlResetHandler);
301: if (iresult < 0) {
302: emsg = Sm1_popErrorMessage("executeString: ");
303: Sm1_pushError2(SerialCurrent,-1,emsg);
304: return(-1);
305: }
306: break;
307: case SM_executeFunction:
308: OxCritical = 0;
1.13 takayama 309: if (NoExecution) {
310: iresult = 0;
311: }else{
312: iresult = Sm1_executeStringByLocalParser();
313: }
1.1 maekawa 314: OxCritical = 1; signal(SIGUSR1,controlResetHandler);
315: if (iresult < 0) {
316: emsg = Sm1_popErrorMessage("executeFunction: ");
1.14 takayama 317: Sm1_pushError2(SerialCurrent,-1,emsg);
318: return(-1);
319: }
320: break;
321: case SM_executeFunctionWithOptionalArgument:
322: OxCritical = 0;
323: if (NoExecution) {
324: iresult = 0;
325: }else{
326: iresult = Sm1_executeStringByLocalParser();
327: }
328: OxCritical = 1; signal(SIGUSR1,controlResetHandler);
329: if (iresult < 0) {
330: emsg = Sm1_popErrorMessage("executeFunctionWithOptionalArgument: ");
1.1 maekawa 331: Sm1_pushError2(SerialCurrent,-1,emsg);
332: return(-1);
333: }
334: break;
335: case SM_popCMO:
1.11 takayama 336: oxSendOXheader(ostreamOut,OX_DATA,SerialOX++);
337: n=Sm1_popCMO(ostreamOut,SerialCurrent);
1.1 maekawa 338: if (message) fprintf(stderr,"Done.\n");
339: break;
340: case SM_popString:
1.11 takayama 341: oxSendOXheader(ostreamOut,OX_DATA,SerialOX++);
342: oxSendCmoString(ostreamOut,Sm1_popString());
1.1 maekawa 343: if (message) fprintf(stderr,"Done.\n");
344: break;
345: case SM_shutdown:
1.5 takayama 346: fprintf(stderr,"Shutting down the engine.\n");
347: exit(0);
348: break;
1.1 maekawa 349: case SM_beginBlock:
350: case SM_endBlock:
351: fprintf(stderr,"This command has not yet been implemented.\n");
352: return(-1);
353: break;
354: default:
355: fprintf(stderr,"Fatal error. Unknown function_id %d\n",id);
356: return(-1);
357: break;
358: }
359: return(0);
360: }
361:
362:
363: nullserver_simplest(int fd) {
364: int c;
365: while(1) {
366: c = readOneByte(fd);
1.17 ! takayama 367: if (c == '@') { return 0; }
1.1 maekawa 368: }
369: }
370:
371:
372: void controlResetHandler(sig)
1.5 takayama 373: int sig;
1.1 maekawa 374: {
375: signal(sig,SIG_IGN);
1.8 takayama 376: cancelAlarm();
1.1 maekawa 377: fprintf(stderr,"From controlResetHandler. OxCritical = %d\n",OxCritical);
378: OxInterruptFlag = 1;
379: if (OxCritical) {
380: return;
381: }else{
1.15 takayama 382: (void) traceShowStack(); traceClearStack();
1.7 takayama 383: #if defined(__CYGWIN__)
384: siglongjmp(EnvOfChildServer,2); /* returns 2 for ctrl-C */
385: #else
1.1 maekawa 386: longjmp(EnvOfChildServer,2); /* returns 2 for ctrl-C */
1.7 takayama 387: #endif
1.1 maekawa 388: }
389: }
390:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to oxserver00.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kxx