Annotation of OpenXM/src/kxx/oxserver00.c, Revision 1.18
1.18 ! takayama 1: /* $OpenXM: OpenXM/src/kxx/oxserver00.c,v 1.17 2013/11/06 06:23:24 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.18 ! takayama 26: #if defined(__CYGWIN__) || defined(__MSYS__)
1.7 takayama 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.18 ! takayama 102: #if defined(__CYGWIN__) || defined(__MSYS__)
1.7 takayama 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.18 ! takayama 134: fprintf(stderr,"Hello world.\n"); OXprintMessage = 1;
! 135: JmpMessage = 1;
! 136:
1.1 maekawa 137: aaa : ;
1.7 takayama 138: #if defined(__CYGWIN__)
1.18 ! takayama 139: if (MYSIGSETJMP(EnvOfChildServer,1)) {
1.7 takayama 140: #else
1.18 ! takayama 141: if (MYSETJMP(EnvOfChildServer)) {
1.7 takayama 142: #endif
1.1 maekawa 143: fprintf(stderr,"childServerMain: jump here.\n");
144: if (OxInterruptFlag == 0) {
145: fprintf(stderr," ?! \n"); fflush(NULL);
146: }
1.15 takayama 147: if (!Calling_ctrlC_hook) {
1.16 takayama 148: Calling_ctrlC_hook = 1; RestrictedMode = 0;
1.15 takayama 149: KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
1.16 takayama 150: RestrictedMode = RestrictedMode_saved;
1.15 takayama 151: }
152: Calling_ctrlC_hook = 0;
1.9 takayama 153: KSexecuteString(" (Computation is interrupted.) ");
1.1 maekawa 154: signal(SIGUSR1,controlResetHandler); goto aaa;
155: } else {
156: if (JmpMessage) fprintf(stderr,"Set EnvOfChildServer.\n");
157: signal(SIGUSR1,controlResetHandler);
158: }
1.7 takayama 159: #if defined(__CYGWIN__)
1.18 ! takayama 160: if (MYSIGSETJMP(EnvOfStackMachine,1)) {
1.7 takayama 161: #else
1.18 ! takayama 162: if (MYSETJMP(EnvOfStackMachine)) {
1.7 takayama 163: #endif
1.9 takayama 164: fprintf(stderr,"childServerMain: jump here by EnvOfStackMachine or timeout.\n");
1.1 maekawa 165: if (OxInterruptFlag == 0) {
166: fprintf(stderr," ?! \n"); fflush(NULL);
167: }
168: /* In case of error in the stack machine, pop the error info
169: and send the error packet. */
170: /* oxSendOXheader(ostream,OX_DATA,SerialOX++);
1.5 takayama 171: oxSendCmoError(ostream);
172: oxSendOXheader(ostream,OX_DATA,SerialOX++);
173: sprintf(sreason,"Jump here by sm1 error.");
174: oxSendCmoError2(ostream,sreason);
1.1 maekawa 175: */
176: Sm1_pushError2(SerialCurrent,-1,"Global jump by sm1 error");
177:
1.15 takayama 178: if (!Calling_ctrlC_hook) {
1.16 takayama 179: Calling_ctrlC_hook = 1; RestrictedMode = 0;
1.15 takayama 180: KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
1.16 takayama 181: RestrictedMode = RestrictedMode_saved;
1.15 takayama 182: }
183: Calling_ctrlC_hook = 0;
1.1 maekawa 184: signal(SIGUSR1,controlResetHandler); goto aaa ;
185: } else {
186: if (JmpMessage) fprintf(stderr,"Set EnvOfStackMachine.\n");
187: if (signal(SIGUSR1,SIG_IGN) != SIG_IGN) {
188: signal(SIGUSR1,controlResetHandler);
189: }
190: }
191:
192: while (1) {
1.11 takayama 193: message = OXprintMessage;
1.1 maekawa 194: if (OxInterruptFlag) {
195: OxCritical = 1;
196: if (message) {fprintf(stderr,"Clearing the read buffer.\n");fflush(NULL); }
1.11 takayama 197: fp2clearReadBuf(ostreamIn); /* clear the read buffer */
1.1 maekawa 198: if (message) {fprintf(stderr,"Throwing OX_SYNC_BALL\n"); fflush(NULL);}
1.11 takayama 199: oxSendSyncBall(ostreamOut);
1.1 maekawa 200: if (message) {fprintf(stderr,"Waiting for OX_SYNC_BALL\n");fflush(NULL);}
1.11 takayama 201: oxWaitSyncBall(ostreamIn);
1.1 maekawa 202: if (message) {fprintf(stderr,"Done changing OX_SYNC_BALL\n"); fflush(NULL);}
203: OxInterruptFlag = 0;
204: OxCritical = 0;
205: goto aaa ;
206: }
207: OxCritical = 0;
1.11 takayama 208: if (fp2select(ostreamIn,-1)) {
1.1 maekawa 209: /* If there is an data in the ostream, then read data in the buffer and
210: read data in the communication stream. */
211: OxCritical = 1;
212: }else{
213: /* interrupted system call */
214: /* This part is never reached. */
215: }
216: OxCritical = 1;
1.11 takayama 217: mtag = oxGetOXheader(ostreamIn,&SerialCurrent); /* get the message_tag */
1.1 maekawa 218: if (message) {
219: fprintf(stderr,"\nmtag is %d (serial=%d) : ",mtag,SerialCurrent);
220: switch(mtag) {
221: case OX_COMMAND: fprintf(stderr," OX_COMMAND \n"); break;
222: case OX_DATA: fprintf(stderr," OX_DATA \n"); break;
223: case OX_SYNC_BALL: fprintf(stderr," OX_SYNC_BALL \n"); break;
224: case -1: fprintf(stderr," End of file. Exiting the server child.\n");
1.10 ohara 225: exit(0); break;
1.1 maekawa 226: default: fprintf(stderr," ?! \n"); break;
227: }
228: }
229: /*sleep(2); /* for dubug OX_SYNC_BALL */
230: switch(mtag) {
231: case OX_COMMAND:
1.11 takayama 232: nullserverCommand(ostreamIn,ostreamOut);
1.1 maekawa 233: goto aaa ; /* We always reset the jump vector. cf. memo1.txt 1998 2/13*/
234: break;
235: case OX_DATA:
1.11 takayama 236: Sm1_pushCMO(ostreamIn);
1.1 maekawa 237: break;
238: case OX_SYNC_BALL:
239: /* if (OxInterruptFlag) think about it later. */
240: break;
241: default:
242: fprintf(stderr,"Fatal error in server.\n");
243: break;
244: }
245: }
246: }
247:
1.11 takayama 248: nullserverCommand(ox_stream ostreamIn,ox_stream ostreamOut) {
1.1 maekawa 249: int id;
250: int mtag;
251: int n;
252: char *name;
253: char *sresult;
254: struct mathCap *mathresult;
255: int iresult;
256: int message = 1;
257: char *emsg;
258: extern void controlResetHandler();
259:
1.11 takayama 260: message = OXprintMessage;
1.1 maekawa 261: /* message_body */
1.11 takayama 262: id = oxGetInt32(ostreamIn); /* get the function_id */
1.12 takayama 263: if (message) {fprintf(stderr,"\nfunction_id is %d; %s\n",id,oxFIDtoStr(id));}
1.1 maekawa 264: switch( id ) {
265: case SM_mathcap:
266: mathresult = (struct mathCap *)Sm1_mathcap();
267: oxPushMathCap(mathresult);
268: break;
269: case SM_setMathCap:
1.11 takayama 270: Sm1_setMathCap(ostreamOut);
1.1 maekawa 271: break;
272: case SM_pops:
273: Sm1_pops();
274: break;
275: case SM_getsp:
276: Sm1_getsp();
277: break;
278: case SM_dupErrors:
279: Sm1_dupErrors();
280: break;
1.3 takayama 281: case SM_pushCMOtag:
282: Sm1_pushCMOtag(SerialCurrent);
1.5 takayama 283: break;
1.1 maekawa 284: case SM_setName:
285: iresult = Sm1_setName();
286: if (iresult < 0) {
287: Sm1_pushError2(SerialCurrent,-1,"setName");
288: }
289: break;
290: case SM_evalName:
291: iresult = Sm1_evalName();
292: if (iresult < 0) {
293: Sm1_pushError2(SerialCurrent,-1,"evalName");
294: }
295: break;
296: case SM_executeStringByLocalParser:
297: OxCritical = 0;
1.13 takayama 298: if (NoExecution) {
299: iresult = 0;
300: }else{
301: iresult = Sm1_executeStringByLocalParser();
302: }
1.1 maekawa 303: OxCritical = 1; signal(SIGUSR1,controlResetHandler);
304: if (iresult < 0) {
305: emsg = Sm1_popErrorMessage("executeString: ");
306: Sm1_pushError2(SerialCurrent,-1,emsg);
307: return(-1);
308: }
309: break;
310: case SM_executeFunction:
311: OxCritical = 0;
1.13 takayama 312: if (NoExecution) {
313: iresult = 0;
314: }else{
315: iresult = Sm1_executeStringByLocalParser();
316: }
1.1 maekawa 317: OxCritical = 1; signal(SIGUSR1,controlResetHandler);
318: if (iresult < 0) {
319: emsg = Sm1_popErrorMessage("executeFunction: ");
1.14 takayama 320: Sm1_pushError2(SerialCurrent,-1,emsg);
321: return(-1);
322: }
323: break;
324: case SM_executeFunctionWithOptionalArgument:
325: OxCritical = 0;
326: if (NoExecution) {
327: iresult = 0;
328: }else{
329: iresult = Sm1_executeStringByLocalParser();
330: }
331: OxCritical = 1; signal(SIGUSR1,controlResetHandler);
332: if (iresult < 0) {
333: emsg = Sm1_popErrorMessage("executeFunctionWithOptionalArgument: ");
1.1 maekawa 334: Sm1_pushError2(SerialCurrent,-1,emsg);
335: return(-1);
336: }
337: break;
338: case SM_popCMO:
1.11 takayama 339: oxSendOXheader(ostreamOut,OX_DATA,SerialOX++);
340: n=Sm1_popCMO(ostreamOut,SerialCurrent);
1.1 maekawa 341: if (message) fprintf(stderr,"Done.\n");
342: break;
343: case SM_popString:
1.11 takayama 344: oxSendOXheader(ostreamOut,OX_DATA,SerialOX++);
345: oxSendCmoString(ostreamOut,Sm1_popString());
1.1 maekawa 346: if (message) fprintf(stderr,"Done.\n");
347: break;
348: case SM_shutdown:
1.5 takayama 349: fprintf(stderr,"Shutting down the engine.\n");
350: exit(0);
351: break;
1.1 maekawa 352: case SM_beginBlock:
353: case SM_endBlock:
354: fprintf(stderr,"This command has not yet been implemented.\n");
355: return(-1);
356: break;
357: default:
358: fprintf(stderr,"Fatal error. Unknown function_id %d\n",id);
359: return(-1);
360: break;
361: }
362: return(0);
363: }
364:
365:
366: nullserver_simplest(int fd) {
367: int c;
368: while(1) {
369: c = readOneByte(fd);
1.17 takayama 370: if (c == '@') { return 0; }
1.1 maekawa 371: }
372: }
373:
374:
375: void controlResetHandler(sig)
1.5 takayama 376: int sig;
1.1 maekawa 377: {
378: signal(sig,SIG_IGN);
1.8 takayama 379: cancelAlarm();
1.1 maekawa 380: fprintf(stderr,"From controlResetHandler. OxCritical = %d\n",OxCritical);
381: OxInterruptFlag = 1;
382: if (OxCritical) {
383: return;
384: }else{
1.15 takayama 385: (void) traceShowStack(); traceClearStack();
1.7 takayama 386: #if defined(__CYGWIN__)
387: siglongjmp(EnvOfChildServer,2); /* returns 2 for ctrl-C */
388: #else
1.1 maekawa 389: longjmp(EnvOfChildServer,2); /* returns 2 for ctrl-C */
1.7 takayama 390: #endif
1.1 maekawa 391: }
392: }
393:
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