Annotation of freem/src/mumps.c, revision 1.4
1.1 snw 1: /*
1.4 ! snw 2: * $Id$
1.1 snw 3: * main module of freem
4: *
5: *
1.3 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.4 ! snw 8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.4 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31:
32: #include <stdlib.h>
33: #include <stddef.h>
34: #include "mpsdef.h"
35: #include "errmsg.h"
36: #include "iniconf.h"
37: #include "namespace.h"
38: #include "transact.h"
39: #include "init.h"
40: #include "consttbl.h"
41: #include <setjmp.h>
42: #include <stdio.h>
43: #include <signal.h>
44: #include <time.h>
45: #include <unistd.h>
46: #include <sys/types.h>
47: #include <sys/wait.h>
48: #include <sys/stat.h>
49: #include <limits.h>
50: #include <sys/types.h>
51: #include <pwd.h>
52: #include <string.h>
53: #include <fcntl.h>
54: #include "version.h"
55: #include "shmmgr.h"
56: #include "jobtab.h"
57: #include <errno.h>
58: #include <pwd.h>
59: #include <grp.h>
60:
61:
62: #if defined(HAVE_GETOPT_H)
63: # include <getopt.h>
64: #endif
65:
66: #if !defined(PATH_MAX) && defined(_SCO_DS)
67: # define PATH_MAX 1024
68: #endif
69:
70: extern int xecline(int typ);
71: extern char *getenv(const char *name);
72: void freem_usage(void);
73: void freem_print_version(void);
74: void init_ztrap(void);
75: void m_log (int, const char *);
76:
77: int main (int argc, char **argv, char **envp)
78: {
79: pid_t fork_pid = 0;
80: short dx_mode = 0;
81:
82: int c;
83: int import_env = FALSE;
84: short skip_init = 0;
85:
86: int option_index = 0;
87:
88: char dx_mcode[512];
89: char startup_routine[256];
90: short routine_mode;
91: char m_dialect[50];
92:
93: char nsnbuf[256];
94:
95: char d_username[40];
96: char d_groupname[40];
97: struct group *d_grp;
98: struct passwd *d_user;
99: gid_t d_gid;
100: uid_t d_uid;
101:
102: short custom_user = FALSE;
103: short custom_group = FALSE;
104:
105: #if defined(HAVE_GETOPT_LONG)
106: struct option long_options[] = {
107: {"help", no_argument, 0, 'h'},
108: {"filter", no_argument, &frm_filter, TRUE},
109: {"standard", required_argument, 0, 's'},
110: {"import", no_argument, &import_env, TRUE},
111: {"quiet", no_argument, &quiet_mode, TRUE},
112: {"restricted", no_argument, &restricted_mode, TRUE},
113: {"routine", required_argument, 0, 'r'},
114: {"namespace", required_argument, 0, 'n'},
115: {"environment", required_argument, 0, 'e'},
116: {"version", no_argument, 0, 'v'},
117: {"execute", required_argument, 0, 'x'},
118: {"daemon", no_argument, 0, 'd'},
119: {"nofork", no_argument, 0, 'k'},
120: {"pidfile", required_argument, 0, 'p'},
121: {"shmsize", required_argument, 0, 'S'},
122: {"user", required_argument, 0, 'u'},
123: {"group", required_argument, 0, 'g'},
124: {0, 0, 0, 0}
125: };
126: #endif
127:
128: char **env;
129: char *varname = (char *) calloc(STRLEN, sizeof(char));
130: char *varval = (char *) calloc(STRLEN, sizeof(char));
131:
132: char *symname = (char *) calloc(STRLEN, sizeof(char));
133: char *symval = (char *) calloc(STRLEN, sizeof(char));
134:
135: int namelen;
136: int vallen;
137:
138: char cli_rtn_path[PATH_MAX] = {0};
139: char *cli_rtn_file;
140: char cli_rtn_name[256];
141:
142: routine_mode = FALSE;
143: strcpy (m_dialect, "FREEM");
144:
145: m_argc = argc; /* save arguments count */
146: m_argv = argv; /* save arguments string */
147: m_envp = envp; /* save environment pointer */
148:
149: strncpy (shm_env, "DEFAULT", 8); /* establish default environment name */
150:
151: strncpy (d_username, "freem", 40);
152: strncpy (d_groupname, "freem", 40);
153:
154: strcpy (zb, argv[0]); /* name with which mumps has been called */
155: stcnv_c2m (zb);
156: strcpy (stack0, argv[0]);
157: stcnv_c2m (stack0);
158:
159:
160: /* strncpy (config_file, SYSCONFDIR"/freem.conf", 100); */
161:
162:
163:
164: #if defined(HAVE_GETOPT_LONG)
165:
166: extern char *optarg;
167: extern int optind, optopt;
168:
169: while (1) {
170:
171: c = getopt_long (argc, argv, "hsfiqRr:n:e:vx:dkpS:u:g:", long_options, &option_index);
172:
173: if (c == -1) break;
174: if (c == '?') freem_usage ();
175:
176: switch (c) {
177: case 'h':
178: freem_usage ();
179: break;
180:
181: case 'f':
182: frm_filter = TRUE;
183: break;
184:
185: case 'i':
186: import_env = TRUE;
187: break;
188:
189: case 'q':
190: quiet_mode = TRUE;
191: break;
192:
193: case 'e': /* specify FreeM environment */
194: strncpy (shm_env, optarg, 255);
195: break;
196:
197: case 'R':
198: restricted_mode = TRUE;
199: break;
200:
201: case 'r': /* startup routine */
202: direct_mode = FALSE;
203: usermode = 0;
204:
205: strcpy (startup_routine, optarg);
206: startup_routine[strlen (startup_routine)] = '\201';
207:
208: routine_mode = TRUE;
209: break;
210:
211: case 'n': /* namespace */
212: {
213: if (validate_namespace (optarg) == TRUE) {
214: strcpy (nsname, optarg);
215: }
216: else {
217: fprintf (stderr, "freem: invalid namespace '%s'\n", optarg);
218: exit (1);
219: }
220:
221: break;
222: }
223: case 'v': /* version */
224: freem_print_version ();
225: break;
226:
227: case 'x': /* execute */
228: direct_mode = FALSE;
229: usermode = 0;
230: dx_mode = 1;
231:
232: strncpy (dx_mcode, optarg, 512 - 1);
233:
234: stcnv_c2m (dx_mcode);
235:
236: break;
237:
238: case 's': /* --standard */
239:
240: if (strcmp (optarg, "M77") == 0) {
241: standard = D_M77;
242: strcpy (m_dialect, "M 1977");
243: }
244: else if (strcmp (optarg, "M84") == 0) {
245: standard = D_M84;
246: strcpy (m_dialect, "M 1984");
247: }
248: else if (strcmp (optarg, "M90") == 0) {
249: standard = D_M90;
250: strcpy (m_dialect, "M 1990");
251: }
252: else if (strcmp (optarg, "M95") == 0) {
253: standard = D_M95;
254: strcpy (m_dialect, "M 1995");
255: }
256: else if (strcmp (optarg, "MDS") == 0) {
257: standard = D_MDS;
258: strcpy (m_dialect, "Millennium Draft Standard");
259: }
260: else if (strcmp (optarg, "M5") == 0) {
261: standard = D_M5;
262: strcpy (m_dialect, "M5");
263: }
264: else if (strcmp (optarg, "FREEM") == 0) {
265: standard = D_FREEM;
266: strcpy (m_dialect, "FREEM");
267: }
268: else {
269: freem_usage ();
270: }
271:
272: break;
273:
274: case 'd': /* --daemon */
275: run_daemon = TRUE;
276: break;
277:
278: case 'k': /* --nofork */
279: nofork = TRUE;
280: break;
281:
282: case 'p': /* --pidfile */
283: pid_file_path = strdup (optarg);
284: break;
285:
286: case 'S': /* --shmsize */
287: shm_init_size = atol (optarg);
288: break;
289:
290: case 'u': /* --user */
291: strncpy (d_username, optarg, 40);
292: custom_user = TRUE;
293: break;
294:
295: case 'g': /* --group */
296: strncpy (d_groupname, optarg, 40);
297: custom_group = TRUE;
298: break;
299:
300:
301: }
302:
303: }
304:
305: #else
306:
307: {
308: extern char *optarg;
309: extern int optind, optopt;
310:
311: while ((c = getopt (argc, argv, "hsfiqRr:n:e:vx:dkpS:u:g:")) != -1) {
312:
313: if (c == '?') freem_usage ();
314:
315: switch (c) {
316:
317: case 'h':
318: freem_usage ();
319: break;
320:
321: case 'f':
322: frm_filter = TRUE;
323: break;
324:
325: case 'i':
326: import_env = TRUE;
327: break;
328:
329: case 'q':
330: quiet_mode = TRUE;
331: break;
332:
333: case 'e': /* specify FreeM environment */
334: strncpy (shm_env, optarg, 255);
335: break;
336:
337: case 'R':
338: restricted_mode = TRUE;
339: break;
340:
341: case 'r': /* startup routine */
342: direct_mode = FALSE;
343: usermode = 0;
344:
345: strcpy (startup_routine, optarg);
346: startup_routine[strlen (startup_routine)] = '\201';
347:
348: routine_mode = TRUE;
349: break;
350:
351: case 'n': /* namespace */
352: strcpy (nsname, optarg);
353: break;
354:
355: case 'v':
356: freem_print_version ();
357: break;
358:
359: case 'x': /* execute */
360: direct_mode = FALSE;
361: usermode = 0;
362: dx_mode = 1;
363:
364: strncpy (dx_mcode, optarg, 512 - 1);
365:
366: stcnv_c2m (dx_mcode);
367:
368: break;
369:
370: case 'd': /* --daemon */
371: run_daemon = TRUE;
372: break;
373:
374: case 'k': /* --nofork */
375: nofork = TRUE;
376: break;
377:
378: case 'p': /* --pidfile */
379: pid_file_path = strdup (optarg);
380: break;
381:
382: case 's': /* --standard */
383:
384: if (strcmp (optarg, "M77") == 0) {
385: standard = D_M77;
386: strcpy (m_dialect, "M 1977");
387: }
388: else if (strcmp (optarg, "M84") == 0) {
389: standard = D_M84;
390: strcpy (m_dialect, "M 1984");
391: }
392: else if (strcmp (optarg, "M90") == 0) {
393: standard = D_M90;
394: strcpy (m_dialect, "M 1990");
395: }
396: else if (strcmp (optarg, "M95") == 0) {
397: standard = D_M95;
398: strcpy (m_dialect, "M 1995");
399: }
400: else if (strcmp (optarg, "MDS") == 0) {
401: standard = D_MDS;
402: strcpy (m_dialect, "Millennium Draft Standard");
403: }
404: else if (strcmp (optarg, "M5") == 0) {
405: standard = D_M5;
406: strcpy (m_dialect, "M5");
407: }
408: else if (strcmp (optarg, "FREEM") == 0) {
409: standard = D_FREEM;
410: strcpy (m_dialect, "FREEM");
411: }
412: else {
413: freem_usage ();
414: }
415:
416: break;
417:
418:
419: case 'S': /* --shmsize */
420: shm_init_size = atol (optarg);
421: break;
422:
423: case 'u': /* --user */
424: strncpy (d_username, optarg, 40);
425: custom_user = TRUE;
426: break;
427:
428: case 'g': /* --group */
429: strncpy (d_groupname, optarg, 40);
430: custom_group = TRUE;
431: break;
432:
433:
434: }
435: }
436: }
437: #endif
438: snprintf (config_file, 4096, "%s/freem/%s/freem.conf", SYSCONFDIR, shm_env);
439:
440: if (run_daemon == TRUE && geteuid() == 0) {
441:
442: if (custom_group) {
443: d_grp = getgrnam (d_groupname);
444:
445: if (d_grp == NULL) {
446: fprintf (stderr, "freem: invalid group '%s'\n", d_groupname);
447: exit (1);
448: }
449:
450: d_gid = d_grp->gr_gid;
451: }
452:
453: if (custom_user) {
454: d_user = getpwnam (d_username);
455:
456: if (d_user == NULL) {
457: fprintf (stderr, "freem: invalid user '%s'\n", d_username);
458: exit (1);
459: }
460:
461: d_uid = d_user->pw_uid;
462: }
463:
464: }
465:
466: if ((nofork == TRUE) && (run_daemon == FALSE)) {
467: freem_usage ();
468: exit (1);
469: }
470:
471: if ((run_daemon == TRUE) && (nofork == FALSE)) {
472:
473: int fork_fd;
474:
475: /* daemonize */
476:
477: fork_pid = fork ();
478:
479: if (fork_pid < 0) {
480: fprintf (stderr, "freem: failure in fork()\r\n");
481: m_log (1, "failure in initial fork()\r\n");
482: exit (1);
483: }
484:
485: if (fork_pid > 0) {
486: exit (0);
487: }
488:
489: if (setsid () < 0) {
490: fprintf (stderr, "freem: failure in setsid()\r\n");
491: m_log (1, "failure in setsid()\r\n");
492: exit (1);
493: }
494:
495: signal (SIGCHLD, SIG_IGN);
496:
497: fork_pid = fork ();
498:
499: if (fork_pid < 0) {
500: fprintf (stderr, "freem: failure in fork()\r\n");
501: m_log (1, "failure in second fork()\r\n");
502: exit (1);
503: }
504:
505: if (fork_pid > 0) {
506: exit (0);
507: m_log (1, "exiting from second fork");
508: }
509:
510: umask (0);
511:
512: chdir ("/");
513:
514: for (fork_fd = sysconf (_SC_OPEN_MAX); fork_fd > 0; fork_fd--) {
515: close (fork_fd);
516: }
517:
518: if (geteuid () == 0) {
519: /* shed privileges */
520:
521: if (custom_group) {
522: fprintf (stderr, "freem: switching to group %s\n", d_groupname);
523: m_log (1, "switching groups");
524:
525: if (setgid (d_gid) == -1) {
526: fprintf (stderr, "freem: failure switching GID\n");
527: m_log (1, "failure switching GIDs");
528: exit (1);
529: }
530: }
531:
532:
533: if (custom_user) {
534: fprintf (stderr, "freem: switching to username %s\n", d_username);
535: m_log (1, "switching users");
536:
537: if (setuid (d_uid) == -1) {
538: fprintf (stderr, "freem: failure switching UID\n");
539: m_log (1, "failure switching UIDs");
540: exit (1);
541: }
542: if (chdir (d_user->pw_dir) == -1) {
543: fprintf (stderr, "freem: chdir failure\n");
544: m_log (1, "failure in chdir");
545: exit (1);
546: }
547: }
548:
549: }
550: else {
551: fprintf (stderr, "not euid 0");
552: }
553:
554: freopen ("/dev/null", "r", stdin);
555: freopen ("/dev/null", "w+", stdout);
556: freopen ("/dev/null", "w+", stderr);
557:
558: run_daemon = TRUE;
559: nofork = FALSE;
560:
561: if (pid_file_path == NULL) {
562: /* no PID file specified. choose one. */
563: uid_t pid_uid;
564: char *home_directory;
565:
566: pid_file_path = (char *) calloc (PATH_MAX, sizeof (char));
567: NULLPTRCHK(pid_file_path,"main");
568:
569: home_directory = (char *) calloc (PATH_MAX, sizeof (char));
570: NULLPTRCHK(home_directory,"main");
571:
572: pid_uid = geteuid ();
573:
574: if (pid_uid == 0) {
575: /* we're running as root */
576: strcpy (pid_file_path, "/var/run/freem.pid");
577: }
578: else {
579: /* our user is a normie */
580: struct passwd *pw = getpwuid (pid_uid);
581:
582: if (pw == NULL) {
583: m_log (1, "main: failure in getpwuid()");
584: }
585:
586: strcpy (home_directory, pw->pw_dir);
587: snprintf (pid_file_path, PATH_MAX - 1, "%s/.freem.pid", home_directory);
588: }
589:
590: free (home_directory);
591:
592: }
593:
594: {
595: char pidfile_buf[256];
596: int errsav;
597:
598: m_log (1, pid_file_path);
599:
600: pid_fd = open (pid_file_path, O_RDWR | O_CREAT, 0640);
601: errsav = errno;
602:
603: if (pid_fd < 0) {
604: m_log (1, "freem: could not open PID file");
605: m_log (1, strerror (errsav));
606: exit (1);
607: }
608:
609: if (lockf (pid_fd, F_TLOCK, 0) < 0) {
610: errsav = errno;
611: m_log (1, "freem: could not lock PID file - perhaps already running?");
612: m_log (1, strerror (errsav));
613: exit (1);
614: }
615:
616: sprintf (pidfile_buf, "%d\n", getpid ());
617: write (pid_fd, pidfile_buf, strlen (pidfile_buf));
618:
619: }
620:
621:
622: } /* END of daemonization */
623:
624: /* handle passing of an arbitrary .m file on the command line */
625: /* this is most often used for shebang-line scripts. */
626: if (optind < argc) {
627:
628: /* not valid for daemon mode */
629: if (run_daemon == TRUE) {
630: fprintf (stderr, "freem: cannot pass --daemon flag in shebang line\r\n");
631: exit (1);
632: }
633:
634: /* bail if file does not exist */
635: if (access (argv[optind], F_OK) == -1) {
636:
637: set_io (UNIX);
638:
639: fprintf (stderr, "Routine %s does not exist.\n", argv[optind]);
640:
641: exit (1);
642:
643: }
644:
645: skip_init = 1;
646:
647: /* initialize FreeM environment */
648: strncpy (nsnbuf, nsname, 255);
649: if (init (nsnbuf) == FALSE) {
650:
651: set_io (UNIX);
652: fprintf (stderr, "\nError initializing FreeM.\n");
653:
654: exit (1);
655:
656: }
657:
658:
659: direct_mode = FALSE;
660: usermode = 0;
661:
662: /* was a path specified at all? */
663: if (strchr (argv[optind], '/') == NULL) {
664:
665: /* the entirety of argv[optind] is the filename */
666: cli_rtn_file = argv[optind];
667:
668: /* use the current directory */
669: sprintf (cli_rtn_path, ".");
670:
671: }
672: else {
673:
674: /* isolate the filename from the path */
675: cli_rtn_file = strrchr (argv[optind], '/') + 1;
676:
677: /* isolate the routine name from the filename */
678: strncpy (cli_rtn_name, cli_rtn_file, strchr (cli_rtn_file, '.') - cli_rtn_file);
679:
680: /* isolate the path from the routine file */
681: strncpy (cli_rtn_path, argv[optind], strrchr (argv[optind], '/') - argv[optind]);
682:
683: /* set_io (UNIX);
684: printf ("cli_rtn_name = '%s' cli_rtn_path = '%s'\n", cli_rtn_name, cli_rtn_path);
685: set_io (MUMPS);
686: */
687: }
688:
689: /* do we have a file extension? */
690: if (strchr (cli_rtn_file, '.') != NULL) {
691:
692: /* if so, just remove it */
693: strncpy (cli_rtn_name, cli_rtn_file, strchr (cli_rtn_file, '.') - cli_rtn_file);
694:
695: }
696: else {
697:
698: /* otherwise, just take a direct copy */
699: strcpy (cli_rtn_name, cli_rtn_file);
700:
701: }
702:
703: /* make this the startup routine */
704: snprintf (startuprou, 256, "^%s\201", cli_rtn_name);
705:
706: /* re-work the namespace config to search for the
707: routine in the discovered path */
708: if (cli_rtn_name[0] == '%') {
709:
710: snprintf (rou0plib, 256, "%s\201", cli_rtn_path);
711: snprintf (rou1plib, 256, "%s\201", cli_rtn_path);
712:
713: }
714: else {
715:
716: snprintf (rou0path, 256, "%s\201", cli_rtn_path);
717: snprintf (rou1path, 256, "%s\201", cli_rtn_path);
718:
719: }
720:
721: }
722:
723:
724: if (!file_exists (config_file)) {
725:
726: set_io (UNIX);
727: fprintf (stderr, "\nFreeM has not been configured. Please run 'fmadm configure'.\n\n\n\n");
728:
729: exit (2);
730:
731: }
732:
733: if (!skip_init) {
734: /* initialize FreeM environment */
735: strncpy (nsnbuf, nsname, 255);
736: if (init (nsnbuf) == FALSE) {
737:
738: set_io (UNIX);
739: fprintf (stderr, "\nError initializing FreeM.\n");
740:
741: exit (1);
742:
743: }
744: }
745:
746: if (first_process == TRUE) {
747:
748: char verstr[500];
749: pid_t stop_requester;
750:
751: if (run_daemon == FALSE) {
752: fprintf (stderr, "freem: re-run with --daemon or -d command-line flags\r\n");
753: cleanup ();
754: exit (1);
755: }
756:
757: stcpy (verstr, FREEM_VERSION_STR);
758: stcnv_m2c (verstr);
759:
760: fprintf (stderr, "Coherent Logic Development FreeM version %s\r\n", verstr);
1.2 snw 761: fprintf (stderr, "freem: shared memory for environment %s initialized (%ld bytes of shared memory @ '%p')\r\nfreem: system ready\r\n", shm_env, (long) shm_init_size, shm_config->dta);
1.1 snw 762:
763: for (;;) {
764:
765: job_set_status (pid, JSTAT_HOUSEKEEPING);
766:
767:
768: if (shm_config->hdr->maintenance_mode == 1) {
769:
770: job_slot_t *slot;
771:
772: fprintf (stderr, "freem: entering maintenance mode\r\n");
773: m_log (1, "freem: entering maintenance mode");
774:
775: for (slot = shm_config->hdr->jobtab_head; slot != NULL; slot = slot->next) {
776:
777: if ((slot->pid != pid) && ((slot->flags & JFLG_FMADM) != JFLG_FMADM)) {
778: kill (slot->pid, SIGINT);
779: }
780:
781: }
782:
783: }
784:
785: if ((stop_requester = job_stop_requested (pid)) != 0) {
786: int connected_jobs;
787:
788: job_set_status (pid, JSTAT_SHUTDOWN);
789:
790: connected_jobs = job_count ();
791:
792: fprintf (stderr, "freem: STOP requested by pid %d\r\n", stop_requester);
793: fprintf (stderr, "freem: there are %d job(s) connected to this environment\r\n", connected_jobs);
794:
795: if (connected_jobs > 1) {
796:
797: fprintf (stderr, "freem: asking non-daemon job(s) to disconnect and halt...\r\n");
798: job_request_all_stop ();
799:
800: fprintf (stderr, "freem: waiting 5 seconds for job(s) to disconnect...\r\n");
801: sleep (5);
802:
803: connected_jobs = job_count ();
804: if (connected_jobs > 1) {
805: fprintf (stderr, "freem: sending SIGTERM to %d job(s)...\r\n", connected_jobs);
806: job_signal_all (SIGTERM);
807: fprintf (stderr, "freem: waiting 5 seconds for job(s) to disconnect...\r\n");
808:
809: sleep (5);
810: }
811:
812: connected_jobs = job_count ();
813: if (connected_jobs > 1) {
814: fprintf (stderr, "freem: sending SIGKILL to %d job(s)...\r\n", connected_jobs);
815: job_signal_all (SIGKILL);
816: }
817:
818: job_gc_mark ();
819: job_gc_sweep ();
820:
821: }
822:
823: fprintf (stderr, "freem: terminating\r\n");
824: cleanup ();
825: exit (0);
826:
827: }
828:
829: job_gc_mark ();
830: job_set_status (pid, JSTAT_IDLE);
831: sleep (1);
832:
833: job_set_status (pid, JSTAT_HOUSEKEEPING);
834: job_gc_sweep ();
835: sleep (1);
836: }
837:
838: }
839:
840:
841: #if !defined(_AIX)
842: if(import_env == TRUE) {
843:
844: int i_maxlen = 255;
845:
846: for(env = envp; *env != 0; env++) {
847:
848: namelen = 0;
849: vallen = 0;
850:
851: varname = strtok(*env, "=");
852: varval = strtok(NULL, "=");
853:
854: if(varval != NULL) {
855: namelen = strlen (varname);
856: vallen = strlen (varval);
857:
858: snprintf (symname, i_maxlen, "ENV.%s\201\201", varname);
859: strncpy (symval, varval, i_maxlen);
860:
861: stcnv_c2m (symval);
862:
863: symtab (set_sym, symname, symval);
864: }
865: }
866: }
867: #endif
868:
869:
870: if (direct_mode == TRUE && quiet_mode == FALSE) {
871:
872: char verstr[500];
873: char version[256];
874:
875: stcpy (verstr, FREEM_VERSION_STR);
876: stcnv_m2c (verstr);
877:
878: snprintf (version, 255, "\r\nCoherent Logic Development FreeM version %s [DIALECT: %s%s]\r\n\201", verstr, m_dialect, (restricted_mode == TRUE ? "/RESTRICTED" : ""));
879: write_m (version);
880:
1.4 ! snw 881: snprintf (version, 255, "Copyright (C) 2014, 2020, 2021, 2023, 2025 Coherent Logic Development LLC\r\n\r\n\201");
1.1 snw 882: write_m (version);
883:
884: printf ("Environment: \t%s\r\n", shm_env);
885: printf ("Environment Daemon:\tPID %d\r\n", shm_config->hdr->first_process);
886: printf ("Interpreter Process:\tPID %d\r\n", pid);
887:
888:
889: }
890: else {
891: write_m ("\r\n\r\n\201");
892: }
893:
894: if (dx_mode) {
895: char k_buf[512];
896:
897: snprintf (k_buf, 512 - 1, "%%TMPINITMCODE\201\201");
898: symtab (set_sym, k_buf, dx_mcode);
899: const_define (k_buf, dx_mcode);
900: }
901:
902: if (routine_mode) {
903: char k_buf[512];
904:
905: snprintf (k_buf, 512 - 1, "%%TMPINITROUTINE\201\201");
906: symtab (set_sym, k_buf, startup_routine);
907: const_define (k_buf, startup_routine);
908: }
909:
910: /* run mumps */
911: xecline (1);
912:
913: exit (0); /* we should never reach that statement */
914:
915: } /* end of main() */
916:
917: void freem_usage(void)
918: {
919: fprintf (stdout, "\nusage: freem [OPTION...]\n\n");
920:
921: fprintf (stdout, "OPTIONS:\n\n");
922:
923: #if defined(HAVE_GETOPT_LONG)
924: fprintf (stdout, "\t-h, --help\n\t\tdisplays this help message\n\n");
925: fprintf (stdout, "\t-i, --import\n\t\timports UNIX environment variables as M locals\n\n");
926: fprintf (stdout, "\t-e <environment-name>, --environment=<environment-name>\n\t\tsets active environment to <environment-name> (DEFAULT if unspecified)\n\n");
927: fprintf (stdout, "\t-f, --filter\n\t\tallows M code to be used as a filter\n\n");
928: fprintf (stdout, "\t-n <NAMESPACE>, --namespace=<NAMESPACE>\n\t\tselects <NAMESPACE> as the startup namespace instead of USER\n\n");
929: fprintf (stdout, "\t-q, --quiet\n\t\tdisables startup messages and prompt string\n\n");
930: fprintf (stdout, "\t-r <LABEL^ROUTINE>, --routine=<LABEL^ROUTINE>\n\t\texecute <LABEL^ROUTINE> on startup instead of entering direct mode\n\n");
931: fprintf (stdout, "\t-s, --standard\n\t\trestrict access to FreeM vendor extensions not present in relevant standards*\n\n");
932: fprintf (stdout, "\t-v, --version\n\t\tdisplay FreeM version information\n\n");
933: fprintf (stdout, "\t-x <MCODE>, --execute=<MCODE>\n\t\texecute M code <MCODE> on startup\n\n");
934: fprintf (stdout, "\t-d, --daemon\n\t\trun the FreeM daemon (one and only one FreeM daemon must always be running)\n\n");
935: fprintf (stdout, "\t-k, --nofork\n\t\trun the FreeM daemon in foreground (requires --daemon)\n\n");
936: fprintf (stdout, "\t-p <PIDFILE>, --pidfile=<PIDFILE>\n\t\tuse <PIDFILE> to record the PID of the FreeM daemon\n\n\n");
937: fprintf (stdout, "\t-S <BYTES>, --shmsize=<BYTES>\n\t\tsets the size of the shared memory segment where FreeM stores the job table, lock table, and IPC table.\n");
938: #else
939: fprintf (stdout, "\t-h\n\t\tdisplays this help message\n\n");
940: fprintf (stdout, "\t-i\n\t\timports UNIX environment variables as M locals\n\n");
941: fprintf (stdout, "\t-e <environment-name>\n\t\tsets active environment to <environment-name> (DEFAULT if unspecified)\n\n");
942: fprintf (stdout, "\t-f\n\t\tallows M code to be used as a filter\n\n");
943: fprintf (stdout, "\t-n <NAMESPACE>\n\t\tselects <NAMESPACE> as the startup namespace instead of USER\n\n");
944: fprintf (stdout, "\t-q\n\t\tdisables startup messages and prompt string\n\n");
945: fprintf (stdout, "\t-r <LABEL^ROUTINE>\n\t\texecute <LABEL^ROUTINE> on startup instead of entering direct mode\n\n");
946: fprintf (stdout, "\t-s\n\t\trestrict access to FreeM vendor extensions not present in relevant standards*\n\n");
947: fprintf (stdout, "\t-v\n\t\tdisplay FreeM version information\n\n");
948: fprintf (stdout, "\t-x <MCODE>\n\t\texecute M code <MCODE> on startup\n\n");
949: fprintf (stdout, "\t-d\n\t\trun the FreeM daemon (one and only one FreeM daemon must always be running)\n\n");
950: fprintf (stdout, "\t-k\n\t\trun the FreeM daemon in foreground (requires --daemon)\n\n");
951: fprintf (stdout, "\t-p <PIDFILE>\n\t\tuse <PIDFILE> to record the PID of the FreeM daemon\n\n\n");
952: fprintf (stdout, "\t-S <BYTES>\n\t\tsets the size of the shared memory segment where FreeM stores the job table, lock table, and IPC table.\n");
953: #endif
954: fprintf (stdout, "\t\t - Each concurrent job takes %d bytes (1 page) of shared memory\n", PG_SIZE);
955: fprintf (stdout, "\t\t - Each LOCK takes %d bytes (2 pages) of shared memory\n", PG_SIZE * 2);
956: fprintf (stdout, "\t\t - Each IPC takes %d bytes (1 page) of shared memory\n\n", PG_SIZE);
957: fprintf (stdout, "\t* FreeM attempts to conform (at least loosely) to the Millennium Draft Standard when this mode is selected.\n\n\n");
958: fprintf (stdout, "Report bugs to: freem-bugs@coherent-logic.com\n");
959: fprintf (stdout, "FreeM home page: <https://freem.coherent-logic.com>\n\n");
960:
961: exit (1);
962: }
963:
964: void freem_print_version(void)
965: {
966: char verstr[500];
967: stcpy (verstr, FREEM_VERSION_STR);
968: stcnv_m2c (verstr);
969:
970: fprintf (stdout, "Coherent Logic Development FreeM %s\n", verstr);
971: fprintf (stdout, "Copyright (C) 2014, 2020, 2021, 2023 Coherent Logic Development LLC\n\n");
972: fprintf (stdout, "License AGPLv3+: GNU AGPL version 3 or later <https://gnu.org/license/agpl-3.0.html>\n");
973: fprintf (stdout, "This is free software: you are free to change and redistribute it.\n");
974: fprintf (stdout, "There is NO WARRANTY, to the extent permitted by law.\n");
975:
976: exit (0);
977: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mumps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src