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