Annotation of freem/src/init.c, revision 1.2
1.1 snw 1: /*
2: * *
3: * * *
4: * * *
5: * ***************
6: * * * * *
7: * * MUMPS *
8: * * * * *
9: * ***************
10: * * *
11: * * *
12: * *
13: *
14: * init.c
15: * FreeM initialization
16: *
17: *
18: * Author: Serena Willis <jpw@coherent-logic.com>
19: * Copyright (C) 1998 MUG Deutschland
20: * Copyright (C) 2020 Coherent Logic Development LLC
21: *
22: *
23: * This file is part of FreeM.
24: *
25: * FreeM is free software: you can redistribute it and/or modify
26: * it under the terms of the GNU Affero Public License as published by
27: * the Free Software Foundation, either version 3 of the License, or
28: * (at your option) any later version.
29: *
30: * FreeM is distributed in the hope that it will be useful,
31: * but WITHOUT ANY WARRANTY; without even the implied warranty of
32: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33: * GNU Affero Public License for more details.
34: *
35: * You should have received a copy of the GNU Affero Public License
36: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
37: *
38: **/
39:
40: #include <stdio.h>
41: #include <stdlib.h>
42: #include <string.h>
43: #include <unistd.h>
44: #include <limits.h>
45: #include <sys/types.h>
46: #include <sys/stat.h>
47: #include <pwd.h>
48: #include <time.h>
49: #include <errno.h>
50: #include <sys/ioctl.h>
1.2 ! snw 51:
! 52: #if defined(__sun)
! 53: # include <termio.h>
! 54: #else
! 55: # include <termios.h>
! 56: #endif
1.1 snw 57:
58: #include "config.h"
59:
60: #if defined(HAVE_MWAPI_MOTIF)
61: # include <Xm/Xm.h>
62: #endif
63:
64: #include "mpsdef.h"
65: #include "transact.h"
66: #include "namespace.h"
67: #include "events.h"
68: #include "mdebug.h"
69: #include "shmmgr.h"
70: #include "locktab.h"
71: #include "jobtab.h"
72: #include "datatypes.h"
73: #include "objects.h"
74:
75: #ifdef HAVE_LIBREADLINE
76: # if defined(HAVE_READLINE_READLINE_H)
77: # include <readline/readline.h>
78: # elif defined(HAVE_READLINE_H)
79: # include <readline.h>
80: # else /* !defined(HAVE_READLINE_H) */
81: extern char *readline ();
82: # endif /* !defined(HAVE_READLINE_H) */
83: char *cmdline = NULL;
84: #else /* !defined(HAVE_READLINE_READLINE_H) */
85: /* no readline */
86: #endif /* HAVE_LIBREADLINE */
87:
88: #ifdef HAVE_READLINE_HISTORY
89: # if defined(HAVE_READLINE_HISTORY_H)
90: # include <readline/history.h>
91: # elif defined(HAVE_HISTORY_H)
92: # include <history.h>
93: # else /* !defined(HAVE_HISTORY_H) */
94: extern void add_history ();
95: extern int write_history ();
96: extern int read_history ();
97: # endif /* defined(HAVE_READLINE_HISTORY_H) */
98: /* no history */
99: #endif /* HAVE_READLINE_HISTORY */
100:
101: #if defined(HAVE_WIRINGPI_H)
102: # include <wiringPi.h>
103: #endif
104:
105: #if !defined(PATH_MAX) && defined(_SCO_DS)
106: # define PATH_MAX 4096
107: #endif
108:
109: #if !defined(PATH_MAX) && defined(__gnu_hurd__)
110: # define PATH_MAX 1024
111: #endif
112:
113: #if !defined(PATH_MAX) && defined(__sun__)
114: # include <limits.h>
115: #endif
116:
117: #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
118: # include <sys/syslimits.h>
119: #endif
120:
121: #define SHMKEY 0x990120
122: #define SHMSIZ 1048576
123:
124: void init_process(void);
125: void init_devtable(void);
126: void init_signals(void);
127: void init_timezone(void);
128: void init_freem_path(void);
129:
130: #if defined(HAVE_LIBREADLINE)
131: void init_readline(void);
132: #endif
133:
134: void init_execution_context(void);
135: void init_io(void);
136: void init_random_number(void);
137: void init_ztrap(void);
138: void init_ssvn(void);
139: void init_terminal(void);
140: void init_estack(void);
141:
142: void init_mwapi(void);
143:
144: short init (char *namespace_name)
145: {
146: short retval;
147:
148: init_process ();
149: init_devtable ();
150: init_signals ();
151: init_freem_path ();
152: init_timezone ();
153:
154: #if defined(HAVE_LIBREADLINE)
155: init_readline ();
156: #endif
157:
158: init_execution_context ();
159:
160: if (run_daemon == FALSE) {
161: init_io ();
162: }
163:
164: init_random_number ();
165: init_ztrap ();
166:
167: retval = shm_init (shm_init_size);
168:
169: if (retval == SHMS_GET_ERR) {
170: fprintf (stderr, "init: error initializing shared memory [errno %d]\r\n", errno);
171: exit (1);
172: }
173:
174: symtab_init ();
175: tp_init ();
176:
177: set_namespace (namespace_name, FALSE);
178:
179: if (first_process) {
180: fprintf (stderr, "init: we are the first process in the environment (pid %d)\r\n", pid);
181: }
182:
183: if (first_process) fprintf (stderr, "init: initializing job table\r\n");
184: jobtab_init ();
185:
186: if (first_process) fprintf (stderr, "init: adding job to job table\r\n");
187: job_init (FALSE);
188:
189: if (first_process) fprintf (stderr, "init: initializing structured system variables\r\n");
190: init_ssvn ();
191:
192: if (first_process) fprintf (stderr, "init: initializing terminal\r\n");
193: init_terminal ();
194:
195: if (first_process) fprintf (stderr, "init: initializing asynchronous events\r\n");
196: evt_init ();
197:
198: if (first_process) fprintf (stderr, "init: initializing debugger\r\n");
199: dbg_init ();
200:
201: if (first_process) fprintf (stderr, "init: initializing error stack\r\n");
202: init_estack();
203:
204: etrap[0] = EOL;
205: ecode[0] = EOL;
206: estack = 0;
207:
208: init_mwapi();
209:
210: if (merr () == OK) {
211: return TRUE;
212: }
213:
214: return FALSE;
215: }
216:
217: void init_process (void)
218: {
219: pid = getpid (); /* get $J = process ID */
220: umask (0); /* protection bits mask to full rights */
221: snprintf (fp_conversion, 9, "%%.%df\201", DBL_DIG);
222:
223: if (fp_mode) {
224: zprecise = DBL_DIG;
225: }
226: else {
227: zprecise = 100;
228: }
229: }
230:
231: void init_devtable (void)
232: {
233: register int i;
234: register int j;
235:
236: for (j = 0; j <= MAXDEV; j++) { /* init. translation tables */
237:
238: for (i = 0; i < 256; i++) {
239: G0I[j][i] = (char) i;
240: G0O[j][i] = (char) i;
241: G1I[j][i] = (char) i;
242: G1O[j][i] = (char) i;
243: }
244:
245: G0I[j][UNSIGN (EOL)] = NUL;
246: G0O[j][UNSIGN (EOL)] = NUL;
247: G1I[j][UNSIGN (EOL)] = NUL;
248: G1O[j][UNSIGN (EOL)] = NUL;
249: G0I[j][UNSIGN (DELIM)] = NUL;
250: G0O[j][UNSIGN (DELIM)] = NUL;
251: G1I[j][UNSIGN (DELIM)] = NUL;
252: G1O[j][UNSIGN (DELIM)] = NUL;
253: G0I[j][256] = EOL;
254: G0O[j][256] = EOL;
255: G1I[j][256] = EOL;
256: G1O[j][256] = EOL;
257:
258: }
259:
260: #ifdef SCO
261: #ifndef HACK_NOXLATE
262: G0I[HOME][245] = 64;
263: G0O[HOME][64] = 245; /* Paragraph */
264: G0I[HOME][142] = 91;
265: G0O[HOME][91] = 142; /* A umlaut */
266: G0I[HOME][153] = 92;
267: G0O[HOME][92] = 153; /* O umlaut */
268: G0I[HOME][154] = 93;
269: G0O[HOME][93] = 154; /* U umlaut */
270: G0I[HOME][132] = 123;
271: G0O[HOME][123] = 132; /* a umlaut */
272: G0I[HOME][148] = 124;
273: G0O[HOME][124] = 148; /* o umlaut */
274: G0I[HOME][129] = 125;
275: G0O[HOME][125] = 129; /* u umlaut */
276: G0I[HOME][225] = 126;
277: G0O[HOME][126] = 225; /* sharp s */
278: #endif/*HACK_NOXLATE*/
279:
280: /* DEC Special graphics */
281: G1I[HOME][254] = 96;
282: G1O[HOME][96] = 254; /* diamond */
283: G1I[HOME][176] = 97;
284: G1O[HOME][97] = 176; /* checker board */
285: G1I[HOME][241] = 99;
286: G1O[HOME][99] = 241; /* FF */
287: G1I[HOME][242] = 100;
288: G1O[HOME][100] = 242; /* CR */
289: G1I[HOME][243] = 101;
290: G1O[HOME][101] = 243; /* LF */
291: G1I[HOME][248] = 102;
292: G1O[HOME][102] = 248; /* degree sign */
293: G1I[HOME][241] = 103;
294: G1O[HOME][103] = 241; /* plus minus */
295: G1I[HOME][244] = 104;
296: G1O[HOME][104] = 244; /* NL */
297: G1I[HOME][251] = 105;
298: G1O[HOME][105] = 251; /* VT */
299: G1I[HOME][217] = 106;
300: G1O[HOME][106] = 217; /* lower right corner */
301: G1I[HOME][191] = 107;
302: G1O[HOME][107] = 191; /* upper right corner */
303: G1I[HOME][218] = 108;
304: G1O[HOME][108] = 218; /* upper left corner */
305: G1I[HOME][192] = 109;
306: G1O[HOME][109] = 192; /* lower left corner */
307: G1I[HOME][197] = 110;
308: G1O[HOME][110] = 197; /* cross */
309: G1I[HOME][200] = 111;
310: G1O[HOME][111] = 200; /* linescan 5 */
311: G1I[HOME][201] = 112;
312: G1O[HOME][112] = 201; /* linescan 4 */
313: G1I[HOME][196] = 113;
314: G1O[HOME][113] = 196; /* linescan 3 */
315: G1I[HOME][202] = 114;
316: G1O[HOME][114] = 202; /* linescan 2 */
317: G1I[HOME][203] = 115;
318: G1O[HOME][115] = 203; /* linescan 1 */
319: G1I[HOME][195] = 116;
320: G1O[HOME][116] = 195; /* left junction */
321: G1I[HOME][180] = 117;
322: G1O[HOME][117] = 180; /* right junction */
323: G1I[HOME][193] = 118;
324: G1O[HOME][118] = 193; /* lower junction */
325: G1I[HOME][194] = 119;
326: G1O[HOME][119] = 194; /* upper junction */
327: G1I[HOME][179] = 120;
328: G1O[HOME][120] = 179; /* vertival bar */
329: G1I[HOME][243] = 121;
330: G1O[HOME][121] = 243; /* lower equals */
331: G1I[HOME][242] = 122;
332: G1O[HOME][122] = 242; /* greater equals */
333: G1I[HOME][227] = 123;
334: G1O[HOME][123] = 227; /* pi */
335: G1I[HOME][246] = 124;
336: G1O[HOME][124] = 246; /* not equals */
337: G1I[HOME][128] = 125;
338: G1O[HOME][125] = 128; /* euro sign */
339: G1I[HOME][250] = 126;
340: G1O[HOME][126] = 250; /* centered dot */
341: #endif /* SCO */
342: }
343:
344: void init_signals (void)
345: {
346: sig_init ();
347: }
348:
349: void init_timezone (void)
350: {
351:
352: struct tm lt;
353: struct tm gt;
354:
355: unsigned long gmt;
356: unsigned long lmt;
357:
358: long clock;
359:
360: #ifdef __CYGWIN__
361:
362: tzset (); /* may be required in order */
363: /* to guarantee _timezone set */
364: #else
365:
366: clock = time (0L);
367: lt = *localtime (&clock);
368: gt = *gmtime (&clock);
369:
370: /* This is awkward but I think it is portable: steve_morris */
371: gmt = gt.tm_year * 365;
372: gmt = (gmt + gt.tm_yday) * 24;
373: gmt = (gmt + gt.tm_hour) * 60;
374: gmt = (gmt + gt.tm_min);
375:
376: lmt = lt.tm_year * 365;
377: lmt = (lmt + lt.tm_yday) * 24;
378: lmt = (lmt + lt.tm_hour) * 60;
379: lmt = (lmt + lt.tm_min);
380:
381: FreeM_timezone = (gmt - lmt) * 60;
382: tzoffset = -FreeM_timezone;
383:
384: #endif /* __CYGWIN__ */
385:
386:
387: }
388:
389: void init_freem_path (void)
390: {
391:
392: if((freem_path = malloc(PATH_MAX + 1)) == NULL) {
393: fprintf(stderr, "Can't allocate freem_path. Exiting.");
394:
395: exit(1);
396: }
397:
398: freem_path[0] = NUL;
399:
400: /* check where I'm being executed from */
401: #ifdef __linux__
402: readlink ("/proc/self/exe", freem_path, PATH_MAX);
403: #endif
404: #ifdef __FreeBSD__
405: readlink ("/proc/curproc/file", freem_path, PATH_MAX);
406: #endif
407: #ifdef __sun
408: readlink ("/proc/self/path/a.out", freem_path, PATH_MAX);
409: #endif
410:
411: if(freem_path[0] == NUL) {
412: /* we don't know where we came from */
413: }
414:
415: getcwd (curdir, PATHLEN);
416: stcnv_c2m (curdir);
417:
418: }
419:
420: #if defined(HAVE_LIBREADLINE)
421: void init_readline (void)
422: {
423: uid_t uid = geteuid ();
424: struct passwd *pw = getpwuid (uid);
425: char *pw_buf;
426:
427: pw_buf = (char *) calloc (strlen(pw->pw_dir) + 1, sizeof(char));
428: strcpy (pw_buf, pw->pw_dir);
429:
430: snprintf (history_file, 256, "%s/.freem_history", pw_buf);
431:
432: free (pw_buf);
433:
434: using_history ();
435: read_history (history_file);
436: }
437: #endif
438:
439: void init_execution_context (void)
440: {
441: register int i;
442:
443: obj_init ();
444:
445: merr_clear ();
446:
447: codptr = code;
448: code[0] = EOL; /* init code_pointer */
449: partition = calloc ((unsigned) (PSIZE + 2), 1);
450:
451: if (partition == NULL) exit (2); /* could not allocate stuff... */
452:
453: for (i = 0; i < MAXNO_OF_RBUF; i++) {
454: rbuf_flags[i].standard = standard;
455: }
456:
457: for (i = 0; i < NESTLEVLS; i++) {
458: extr_types[i] = DT_STRING;
459: }
460:
461: symlen = PSIZE;
462: s = &partition[PSIZE] - 256; /* pointer to symlen_offset */
463: argptr = partition; /* pointer to beg of tmp-storage */
464:
465: svntable = calloc ((unsigned) (UDFSVSIZ + 1), 1);
466: if (svntable == NULL) exit (2); /* could not allocate stuff... */
467:
468: svnlen = UDFSVSIZ; /* begin of udf_svn_table */
469: buff = calloc ((unsigned) NO_OF_RBUF * (unsigned) PSIZE0, 1); /* routine buffer pool */
470: if (buff == NULL) exit (2); /* could not allocate stuff... */
471:
472:
473: newstack = calloc ((unsigned) NSIZE, 1);
474: if (newstack == NULL) exit (2); /* could not allocate stuff... */
475:
476: #ifdef DEBUG_NEWPTR
477: printf("Allocating newptr stack...\r\n");
478: #endif
479:
480: newptr = newstack;
481: newlimit = newstack + NSIZE - 1024;
482:
483:
484: namstck = calloc ((unsigned) NESTLEVLS * 13, 1);
485: if (namstck == NULL) exit (2); /* could not allocate stuff... */
486:
487: *namstck = EOL;
488: *(namstck + 1) = EOL;
489: namptr = namstck; /* routine name stack pointer */
490: framstck = calloc ((unsigned) NESTLEVLS * 256, 1);
491: if (framstck == NULL) exit (2); /* could not allocate stuff... */
492:
493: *framstck = EOL;
494: *(framstck + 1) = EOL;
495: dofrmptr = framstck; /* DO_frame stack pointer */
496: cmdstack = calloc ((unsigned) NESTLEVLS * 256, 1);
497: if (cmdstack == NULL) exit (2); /* could not allocate stuff... */
498:
499: cmdptr = cmdstack; /* command stack */
500:
501: rouend = rouins = rouptr = buff;
502: roucur = buff + (NO_OF_RBUF * PSIZE0 + 1);
503: *rouptr = EOL;
504: *(rouptr + 1) = EOL;
505: *(rouptr + 2) = EOL;
506:
507: err_suppl[0] = EOL; /* empty out supplemental error info */
508: }
509:
510: void init_estack (void)
511: {
512: stcpy (merr_stack[0].PLACE, "xecline()\201");
513: }
514:
515: #if defined(HAVE_MWAPI_MOTIF)
516: void init_mwapi (void)
517: {
518: /*
519: if (getenv("DISPLAY") != NULL) {
520: gtk_init (0, NULL);
521: }
522: */
523: //TODO: init Motif/libXt
524: }
525: #else
526: void init_mwapi (void)
527: {
528: return;
529: }
530: #endif
531:
532: void init_io (void)
533: {
534: register int i;
535:
536: /* initialize screen */
537: setbuf (stdin, NULL); /* no input buffering */
538: glvnflag.all = 0L;
539: stcpy (buff, "\201");
540: writeHOME (buff);
541: sq_modes[0] = '+';
542: for (i = 0; i <= MAXDEV; ug_buf[i++][0] = EOL); /* init read-buffers */
543:
544: crlf[HOME] = frm_filter;
545:
546: if (hardcopy) zbreakon = ENABLE; /* enable CTRL/B */
547:
548: set_io (MUMPS); /* set i/o parameters */
549:
550: #if !defined(__AMIGA)
551: if (ttyname (HOME)) { /* for $IO of HOME */
552: strcpy (dev[HOME], ttyname (HOME));
553: dev[HOME][strlen (dev[HOME])] = EOL;
554: }
555: else {
556: dev[HOME][0] = EOL; /* ...we are in a pipe */
557: }
558: #else
559: strcpy (dev[HOME], "CONSOLE:");
560: #endif
561:
562: /* init function keys */
563: for (i = 0; i < 44; zfunkey[i++][0] = EOL);
564: }
565:
566: void init_random_number (void)
567: {
568:
569: srand (time (NULL));
570:
571: if ((nrandom = time (0L) * getpid ()) < 0) {
572: nrandom = (-nrandom);
573: }
574:
575: }
576:
577: void init_ztrap (void)
578: {
579:
580: if (frm_filter) {
581: ztrap[0][0] = EOL; /* no default ztrap for filters */
582: }
583: else if (startuprou[0] == '^') {
584: stcpy (ztrap[0], startuprou);
585: }
586: else {
587: stcpy (ztrap[0], "^%SYSINIT\201");
588: }
589:
590: /* $ZT to be xecuted on startup */
591:
592: stcpy (ztrap[NESTLEVLS + 1], ztrap[0]); /* DSM V.2 error trapping */
593:
594: }
595:
596: void init_ssvn(void)
597: {
598: ssvn_job_update ();
599: ssvn_display_update ();
600: ssvn_routine_update ();
601: ssvn_library_update ();
602: if (first_process) ssvn_system_update ();
603: }
604:
605: void init_terminal(void)
606: {
607: xpos[HOME] = 80;
608: ypos[HOME] = 24;
609: }
610:
611: void reset_terminal(void)
612: {
613: struct termio tpara;
614:
615: ioctl (0, TCGETA, &tpara);
616:
617: tpara.c_lflag |= (ECHO | ICANON); /* enable echo/no cbreak mode */
618: tpara.c_iflag |= ICRNL; /* cr-lf mapping */
619: tpara.c_oflag |= ONLCR; /* cr-lf mapping */
620: tpara.c_cc[VMIN] = EOT;
621: tpara.c_cc[VTIME] = -1;
622:
623: ioctl (0, TCSETA, &tpara);
624: }
625:
626: void cleanup (void)
627: {
628: char k_buf[256];
629: int ch;
630:
631: /* remove this job's entry from ^$JOB SSVN */
632: snprintf (k_buf, 255, "^$JOB\202%d\201", pid);
633: symtab_shm (kill_sym, k_buf, " \201");
634:
635: reset_terminal ();
636:
637: if (tp_level > 0) {
638:
639: if (direct_mode == TRUE) {
640: fprintf (stderr, "UNCOMMITTED TRANSACTIONS EXIST:\n\n");
641: tp_tdump ();
642: set_io (UNIX);
643: fprintf (stderr, "\nWould you like to c)ommit or r)ollback the above transactions and their operations? ($TLEVEL = %d) ", tp_level);
644:
645: for (;;) {
646: ch = fgetc (stdin);
647:
648: if (ch == 'c' || ch == 'C') {
649: while (tp_level > 0) tp_tcommit ();
650:
651: fprintf (stderr, "\n\nTransactions have been committed.\n");
652:
653: break;
654: }
655: else if (ch == 'r' || ch == 'R') {
656: tp_trollback (tp_level);
657:
658: fprintf (stderr, "\n\nTransactions have been rolled back.\n");
659:
660: break;
661: }
662: else {
663: fprintf (stderr, "\n\nInvalid input '%c'. Must choose c)ommit or r)ollback.\n", ch);
664: }
665: }
666: }
667: else {
668: fprintf (stderr, "Uncommitted transactions exist. Rolling back.\n");
669: tp_trollback (tp_level);
670: }
671: }
672:
673: #if defined(HAVE_LIBREADLINE)
674: write_history (history_file);
675: #endif
676:
677: locktab_unlock_all ();
678: job_remove (pid);
679:
680: shm_exit ();
681:
682: if (run_daemon == TRUE) {
683:
684: if (pid_fd != -1) {
685: lockf (pid_fd, F_ULOCK, 0);
686: close (pid_fd);
687: }
688:
689: if (pid_file_path != NULL) {
690: unlink (pid_file_path);
691: }
692:
693: }
694:
695:
696:
697: free (buff); /* free previously allocated space */
698: free (svntable);
699: if (partition) free (partition);
700: if (apartition) free (apartition);
701:
702:
703: free (newstack);
704:
705:
706: if (v22size) free (v22ali);
707:
708: return;
709: } /* end of cleanup */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to init.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src