Annotation of freem/src/fmadm.c, revision 1.16
1.1 snw 1: /*
1.16 ! snw 2: * $Id: fmadm.c,v 1.15 2025/03/24 20:58:05 snw Exp $
1.1 snw 3: * FreeM Administration Tool
4: *
5: *
1.6 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.7 snw 8: * Copyright (C) 2020, 2023, 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.8 snw 26: * $Log: fmadm.c,v $
1.16 ! snw 27: * Revision 1.15 2025/03/24 20:58:05 snw
! 28: * Try using DosCopy API instead of built-in cp function on OS/2
! 29: *
1.15 snw 30: * Revision 1.14 2025/03/24 20:57:06 snw
31: * Try using DosCopy API instead of built-in cp function on OS/2
32: *
1.14 snw 33: * Revision 1.13 2025/03/24 20:15:09 snw
34: * Set file permissions on freemd.exe on OS/2 in fmadm configure
35: *
1.13 snw 36: * Revision 1.12 2025/03/24 20:13:34 snw
37: * Set file permissions on freemd.exe on OS/2 in fmadm configure
38: *
1.12 snw 39: * Revision 1.11 2025/03/24 19:25:48 snw
40: * Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
41: *
1.11 snw 42: * Revision 1.10 2025/03/24 19:22:16 snw
43: * Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
44: *
1.10 snw 45: * Revision 1.9 2025/03/24 19:19:42 snw
46: * Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
47: *
1.9 snw 48: * Revision 1.8 2025/03/22 18:43:54 snw
49: * Make STRLEN 255 chars and add BIGSTR macro for larger buffers
50: *
1.8 snw 51: * Revision 1.7 2025/03/09 19:14:25 snw
52: * First phase of REUSE compliance and header reformat
53: *
1.7 snw 54: *
55: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
56: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 57: **/
58:
59: #include <sys/types.h>
60: #include <sys/stat.h>
61: #include <stddef.h>
62: #include <stdio.h>
63: #include <string.h>
64: #include <dirent.h>
65: #include <stdlib.h>
66: #include <unistd.h>
67: #include <errno.h>
1.4 snw 68: #include <ctype.h>
1.1 snw 69: #include "config.h"
70: #include "transact.h"
71: #include "namespace.h"
72: #include "fs.h"
73:
1.14 snw 74: #if defined(__OS2__)
75: # include <os2.h>
76: #endif
77:
1.1 snw 78: #ifdef HAVE_LIBREADLINE
79: # if defined(HAVE_READLINE_READLINE_H)
80: # include <readline/readline.h>
81: # elif defined(HAVE_READLINE_H)
82: # include <readline.h>
83: # else /* !defined(HAVE_READLINE_H) */
84: extern char *readline ();
85: # endif /* !defined(HAVE_READLINE_H) */
86: /*char *cmdline = NULL;*/
87: #else /* !defined(HAVE_READLINE_READLINE_H) */
88: /* no readline */
89: #endif /* HAVE_LIBREADLINE */
90:
91: #ifdef HAVE_READLINE_HISTORY
92: # if defined(HAVE_READLINE_HISTORY_H)
93: # include <readline/history.h>
94: # elif defined(HAVE_HISTORY_H)
95: # include <history.h>
96: # else /* !defined(HAVE_HISTORY_H) */
97: extern void add_history ();
98: extern int write_history ();
99: extern int read_history ();
100: # endif /* defined(HAVE_READLINE_HISTORY_H) */
101: /* no history */
102: #endif /* HAVE_READLINE_HISTORY */
103:
104:
105: #include "fmadm.h"
106: #include "errmsg.h"
107: #include "iniconf.h"
108: #include "init.h"
109: #include "version.h"
110: #include "shmmgr.h"
111: #include "jobtab.h"
112: #include "locktab.h"
113:
114: /* namespace configuration */
115: char fma_environment[STRLEN];
116: char fma_namespace[STRLEN];
1.8 snw 117: char fma_routine_path[PATHLEN];
118: char fma_global_path[PATHLEN];
119: char fma_journal_path[PATHLEN];
120: char fma_pct_global_path[PATHLEN];
121: char fma_pct_routine_path[PATHLEN];
1.1 snw 122: char fma_journal_cut_threshold[STRLEN];
1.8 snw 123: char fma_locktab[PATHLEN];
1.1 snw 124: short fma_base_opt = 1;
125: short fma_min_args = 2;
126: short fma_explicit_namespace = FALSE;
127: short fma_explicit_environment = FALSE;
128:
129: /* miscellaneous global state */
130: char obj_str[STRLEN];
131:
132: extern char config_file[4096];
133:
134: int fm_shell(void);
135: void fm_checkperms(void);
136: void fm_reconfigure(void);
137: void fm_configure(void);
138: void fm_write (FILE *file, char *buf);
139: int fma_jobs_remove (int optc, char **opts);
140:
141: int main (int argc, char **argv)
142: {
143: char action[STRLEN];
144:
145: short act = -1;
146: short obj = -1;
147:
148: char **opts;
149: int optc = argc - 3;
150:
151: int i = 0;
152: int j = 1;
153: int base_arg = 4;
154: int k = 0;
155:
156: short got_action = FALSE;
157: short got_object = FALSE;
158:
159:
160: /* snprintf (config_file, 4096, "%s/freem.conf", SYSCONFDIR); */
161:
162: base_arg = 1;
163:
164: /* enforce action in argv[1] */
165: if (argc > 1) {
166: if (argv[1][0] == '-') {
167: fprintf (stderr, "fmadm: first argument, if given, must be an action, not a flag\n");
168: fmadm_usage ();
169: exit (1);
170: }
171: }
172:
173: for (i = base_arg; i < argc; i++) {
174: if (i == 1 && isalpha (argv[i][0])) {
175: got_action = TRUE;
176: strncpy (action, argv[i], STRLEN - 1);
177: base_arg++;
178: }
179: if (i == 2 && isalpha (argv[i][0])) {
180: got_object = TRUE;
181: strncpy (obj_str, argv[i], STRLEN - 1);
182: base_arg++;
183: }
184: if (argv[i][0] == '-') {
185:
186: switch (argv[i][1]) {
187:
188: case 'e':
189: if (argv[i][2] != '=') {
190: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
191: fmadm_usage ();
192: exit (1);
193: }
194:
195: k = 0;
196:
197: for (j = 3; j < strlen (argv[i]); j++) {
198: fma_environment[k++] = argv[i][j];
199: }
200:
201: fma_explicit_environment = TRUE;
202: base_arg++;
203:
204: break;
205:
206: case 'n':
207: if (argv[i][2] != '=') {
208: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
209: fmadm_usage ();
210: exit (1);
211: }
212:
213: k = 0;
214:
215: for (j = 3; j < strlen (argv[i]); j++) {
216: fma_namespace[k++] = argv[i][j];
217: }
218:
219: fma_explicit_namespace = TRUE;
220: base_arg++;
221:
222: break;
223:
224: }
225: }
226: }
227:
228: if (!fma_explicit_environment) snprintf (fma_environment, 4096, "DEFAULT");
229: if (!fma_explicit_namespace) snprintf (fma_namespace, 4096, "SYSTEM");
230:
231: snprintf (config_file, 4096, "%s/freem/%s/freem.conf", SYSCONFDIR, fma_environment);
232:
233: /*
234: printf ("action = '%s' object = '%s' environment = '%s' namespace = '%s' config_file = '%s' base_arg = '%d' next argument = '%s'\n", action, obj_str, fma_environment, fma_namespace, config_file, base_arg, argv[base_arg]);
235: exit(1);
236: */
237:
238: /* override for fmadm configure */
239: if (got_action) {
240: if (strcmp (argv[1], "configure") == 0) {
241: fm_configure ();
242: exit (0);
243: }
244: else if (strcmp (argv[1], "reconfigure") == 0) {
245: fm_reconfigure ();
246: exit (0);
247: }
248: }
249:
250: pid = getpid ();
251:
252: shm_init (16777216);
253: tp_init ();
254: jobtab_init ();
255: job_init (TRUE);
256:
257: fm_sig_init ();
258:
259: /* go to fmadm shell if no arguments passed */
260: if (!got_action && !got_object) return fm_shell ();
261:
262: if (argc > 1 && strcmp (argv[1], "checkperms") == 0) {
263: fm_checkperms ();
264: exit (0);
265: }
266:
267: #if 0
268: /* how many args do we have? */
269: switch (argc) {
270:
271: case 3: /* action, object */
272: strncpy (action, argv[1], STRLEN - 1);
273: strncpy (obj_str, argv[2], STRLEN - 1);
274: strncpy (fma_namespace, "SYSTEM", STRLEN - 1);
275:
276: optc = argc - 2;
277:
278: fma_explicit_namespace = FALSE;
279: fma_min_args = 1;
280: base_arg = 3;
281:
282: break;
283:
284: case 4: /* action, object, namespace */
285:
286: strncpy (action, argv[1], STRLEN - 1);
287: strncpy (obj_str, argv[2], STRLEN - 1);
288:
289: if (validate_namespace (argv[3]) == TRUE) {
290: strncpy (fma_namespace, argv[3], STRLEN - 1);
291: fma_min_args = 2;
292: fma_explicit_namespace = TRUE;
293: base_arg = 4;
294: optc = argc - 3;
295: }
296: else {
297: strncpy (fma_namespace, "SYSTEM", 10);
298: fma_min_args = 1;
299: fma_explicit_namespace = FALSE;
300: base_arg = 3;
301: optc = argc - 2;
302: }
303:
304: break;
305:
306: default:
307: if (argc < 4) fmadm_usage();
308:
309: /* we don't know what any but the first two args actually mean */
310: strncpy (action, argv[1], STRLEN - 1);
311: strncpy (obj_str, argv[2], STRLEN - 1);
312:
313: if (validate_namespace (argv[3]) == TRUE) {
314: strncpy (fma_namespace, argv[3], STRLEN - 1);
315: fma_min_args = 2;
316: fma_explicit_namespace = TRUE;
317: base_arg = 4;
318: optc = argc - 3;
319: }
320: else {
321: strncpy (fma_namespace, "SYSTEM", 10);
322: fma_min_args = 1;
323: fma_explicit_namespace = FALSE;
324: base_arg = 3;
325: optc = argc - 2;
326: }
327:
328:
329: }
330: #endif
331:
332: set_namespace (fma_namespace, FALSE);
333:
334: /* allocate opts array */
335:
336: /* first dimension */
337: if ((opts = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
338: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
339: return 1;
340: }
341:
342: /* second dimension */
343: for (i = 0; i < FMA_MAXARGS; i++) {
344: if ((opts[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
345: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
346: return 1;
347: }
348: }
349:
350: /* copy argv[base_arg] through argv[argc - 1] to opts[1] through opts[argc - 3] */
351:
352: strncpy (opts[0], argv[0], STRLEN - 1); /* preserve argv[0] */
353:
354: j = 1;
355: for (i = base_arg; i < argc; i++) {
356: if (i > FMA_MAXARGS) return fmadm_usage(); /* bail if we're going to overrun the array */
357: strncpy (opts[j++], argv[i], STRLEN - 1);
358: }
359:
360: if (strncmp (action, "list", STRLEN - 1) == 0) act = ACT_LIST;
361: else if (strncmp (action, "examine", STRLEN - 1) == 0) act = ACT_EXAMINE;
362: else if (strncmp (action, "verify", STRLEN - 1) == 0) act = ACT_VERIFY;
363: else if (strncmp (action, "compact", STRLEN - 1) == 0) act = ACT_COMPACT;
364: else if (strncmp (action, "repair", STRLEN - 1) == 0) act = ACT_REPAIR;
365: else if (strncmp (action, "create", STRLEN - 1) == 0) act = ACT_CREATE;
366: else if (strncmp (action, "remove", STRLEN - 1) == 0) act = ACT_REMOVE;
367: else if (strncmp (action, "import", STRLEN - 1) == 0) act = ACT_IMPORT;
368: else if (strncmp (action, "export", STRLEN - 1) == 0) act = ACT_EXPORT;
369: else if (strncmp (action, "backup", STRLEN - 1) == 0) act = ACT_BACKUP;
370: else if (strncmp (action, "restore", STRLEN - 1) == 0) act = ACT_RESTORE;
371: else if (strncmp (action, "migrate", STRLEN - 1) == 0) act = ACT_MIGRATE;
372: else if (strncmp (action, "edit", STRLEN -1) == 0) act = ACT_EDIT;
373: else return fmadm_usage();
374:
375: if (strncmp (obj_str, "lock", STRLEN - 1) == 0) obj = OBJ_LOCK;
376: else if (strncmp (obj_str, "zallocate", STRLEN - 1) == 0) obj = OBJ_ZALLOC;
377: else if (strncmp (obj_str, "journal", STRLEN - 1) == 0) obj = OBJ_JOURNAL;
378: else if (strncmp (obj_str, "namespace", STRLEN - 1) == 0) obj = OBJ_NAMESPACE;
379: else if (strncmp (obj_str, "global", STRLEN - 1) == 0) obj = OBJ_GLOBAL;
380: else if (strncmp (obj_str, "routine", STRLEN - 1) == 0) obj = OBJ_ROUTINE;
381: else if (strncmp (obj_str, "job", STRLEN - 1) == 0) obj = OBJ_JOB;
382: else return fmadm_usage();
383:
384: if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
385: fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
386: return 1;
387: }
388:
389: if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
390: fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
391: return 1;
392: }
393:
394: if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
395: fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
396: return 1;
397: }
398:
399: if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
400: fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
401: return 1;
402: }
403:
404: if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
405: strcpy (fma_journal_path, "");
406: }
407:
408: if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
409: strcpy (fma_journal_cut_threshold, "1073741824");
410: }
411:
412: strcpy (gloplib, fma_pct_global_path);
413: stcnv_c2m (gloplib);
414:
415: strcpy (glopath, fma_global_path);
416: stcnv_c2m (glopath);
417:
418:
419: switch (act) {
420:
421:
422: case ACT_LIST:
423: fmadm_exit (fm_list (obj, optc, opts));
424:
425:
426: case ACT_EXAMINE:
427: fmadm_exit (fm_examine (obj, optc, opts));
428:
429:
430: case ACT_VERIFY:
431: fmadm_exit (fm_verify (obj, optc, opts));
432:
433:
434: case ACT_COMPACT:
435: fmadm_exit (fm_compact (obj, optc, opts));
436:
437:
438: case ACT_REPAIR:
439: fmadm_exit (fm_repair (obj, optc, opts));
440:
441:
442: case ACT_CREATE:
443: fmadm_exit (fm_create (obj, optc, opts));
444:
445:
446: case ACT_REMOVE:
447: fmadm_exit (fm_remove (obj, optc, opts));
448:
449:
450: case ACT_IMPORT:
451: fmadm_exit (fm_import (obj, optc, opts));
452:
453:
454: case ACT_EXPORT:
455: fmadm_exit (fm_export (obj, optc, opts));
456:
457:
458: case ACT_BACKUP:
459: fmadm_exit (fm_backup (obj, optc, opts));
460:
461:
462: case ACT_RESTORE:
463: fmadm_exit (fm_restore (obj, optc, opts));
464:
465:
466: case ACT_MIGRATE:
467: fmadm_exit (fm_migrate (obj, optc, opts));
468:
469:
470: case ACT_EDIT:
471: fmadm_exit (fm_edit (obj, optc, opts));
472:
473:
474: default:
475: return fmadm_usage();
476: }
477:
478: return 0; /* should never be reached */
479:
480: } /* main() */
481:
482: int fm_shell (void)
483: {
484:
485: #if defined(HAVE_LIBREADLINE) && !defined(_AIX)
486: int cmd;
487: int i;
488: int j;
489: int obj;
490: int optc;
491: int argc;
492: char **args;
493: char **opts;
494: char *fmarl_buf;
495: char *fma_prompt = (char *) malloc (STRLEN * sizeof (char));
496: char *cmdt = (char *) malloc (65535 * sizeof (char));
497: char *result = (char *) malloc (65535 * sizeof (char));
498:
499: /*
500: strcpy (fma_namespace, "SYSTEM");
501: set_namespace (fma_namespace, FALSE);
502: */
503:
504: snprintf (fma_prompt, STRLEN - 1, "fmadm [%s]> ", fma_namespace);
505:
506: if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
507: fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
508: return 1;
509: }
510:
511: if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
512: fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
513: return 1;
514: }
515:
516: if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
517: fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
518: return 1;
519: }
520:
521: if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
522: fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
523: return 1;
524: }
525:
526: if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
527: strcpy (fma_journal_path, "");
528: }
529:
530: if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
531: strcpy (fma_journal_cut_threshold, "1073741824");
532: }
533:
534: strcpy (gloplib, fma_pct_global_path);
535: stcnv_c2m (gloplib);
536:
537: strcpy (glopath, fma_global_path);
538: stcnv_c2m (glopath);
539:
540: /* allocate args array */
541:
542: /* first dimension */
543: if ((args = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
544: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
545: return 1;
546: }
547:
548: /* second dimension */
549: for (i = 0; i < FMA_MAXARGS; i++) {
550: if ((args[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
551: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
552: return 1;
553: }
554: }
555:
556: /* allocate opts array */
557:
558: /* first dimension */
559: if ((opts = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
560: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
561: return 1;
562: }
563:
564: /* second dimension */
565: for (i = 0; i < FMA_MAXARGS; i++) {
566: if ((opts[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
567: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
568: return 1;
569: }
570: }
571:
572:
573: for (;;) {
574:
575: fmarl_buf = readline (fma_prompt);
576:
577: if (fmarl_buf == (char *) NULL) continue;
578:
579: cmdt = strtok (fmarl_buf, " ");
580:
1.2 snw 581: if (cmdt == (char *) NULL) continue;
582:
1.1 snw 583: for (i = 0; i < strlen (cmdt); i++) cmdt[i] = cmdt[i] | 0140;
584:
585: if (strcmp (cmdt, "exit") == 0) cmd = FMAC_EXIT;
586: else if (strcmp (cmdt, "quit") == 0) cmd = FMAC_EXIT;
587: else if (strcmp (cmdt, "select") == 0) cmd = FMAC_SELECT;
588: else if (strcmp (cmdt, "list") == 0) cmd = FMAC_LIST;
589: else if (strcmp (cmdt, "examine") == 0) cmd = FMAC_EXAMINE;
590: else if (strcmp (cmdt, "verify") == 0) cmd = FMAC_VERIFY;
591: else if (strcmp (cmdt, "compact") == 0) cmd = FMAC_COMPACT;
592: else if (strcmp (cmdt, "repair") == 0) cmd = FMAC_REPAIR;
593: else if (strcmp (cmdt, "create") == 0) cmd = FMAC_CREATE;
594: else if (strcmp (cmdt, "import") == 0) cmd = FMAC_IMPORT;
595: else if (strcmp (cmdt, "export") == 0) cmd = FMAC_EXPORT;
596: else if (strcmp (cmdt, "backup") == 0) cmd = FMAC_BACKUP;
597: else if (strcmp (cmdt, "restore") == 0) cmd = FMAC_RESTORE;
598: else if (strcmp (cmdt, "migrate") == 0) cmd = FMAC_MIGRATE;
599: else if (strcmp (cmdt, "edit") == 0) cmd = FMAC_EDIT;
600: else if (strcmp (cmdt, "set") == 0) cmd = FMAC_SET;
601: else if (strcmp (cmdt, "show") == 0) cmd = FMAC_SHOW;
602: else if (strcmp (cmdt, "remove") == 0) cmd = FMAC_REMOVE;
603: else cmd = FMAC_INVALID;
604:
605: i = 0;
606: while ((result = strtok (NULL, " ")) != NULL) {
607: // printf ("%d = %s\n", i, result);
608: strcpy (args[i++], result);
609: }
610:
611: argc = i;
612: j = 0;
613:
614: for (i = 1; i < argc; i++) {
615: strncpy (opts[j++], args[i], STRLEN - 1);
616: }
617:
618: optc = argc - 1;
619:
620: if (i > 0) {
621:
622: strcpy (obj_str, args[0]);
623:
624: if (strncmp (obj_str, "lock", STRLEN - 1) == 0) obj = OBJ_LOCK;
625: else if (strncmp (obj_str, "zallocate", STRLEN - 1) == 0) obj = OBJ_ZALLOC;
626: else if (strncmp (obj_str, "journal", STRLEN - 1) == 0) obj = OBJ_JOURNAL;
627: else if (strncmp (obj_str, "namespace", STRLEN - 1) == 0) obj = OBJ_NAMESPACE;
628: else if (strncmp (obj_str, "global", STRLEN - 1) == 0) obj = OBJ_GLOBAL;
629: else if (strncmp (obj_str, "routine", STRLEN - 1) == 0) obj = OBJ_ROUTINE;
630: else if (strncmp (obj_str, "job", STRLEN - 1) == 0) obj = OBJ_JOB;
631:
632: }
633:
634: switch (cmd) {
635:
636:
637: case FMAC_SELECT:
638:
639:
640: break;
641:
642:
643: case FMAC_LIST:
644: fm_list (obj, optc, opts);
645: break;
646:
647:
648: case FMAC_EXAMINE:
649: fm_examine (obj, optc, opts);
650: break;
651:
652:
653: case FMAC_VERIFY:
654: fm_verify (obj, optc, opts);
655: break;
656:
657:
658: case FMAC_COMPACT:
659: fm_compact (obj, optc, opts);
660: break;
661:
662:
663: case FMAC_REPAIR:
664: fm_repair (obj, optc, opts);
665: break;
666:
667:
668: case FMAC_CREATE:
669: fm_create (obj, optc, opts);
670: break;
671:
672:
673: case FMAC_REMOVE:
674: fm_remove (obj, optc, opts);
675: break;
676:
677:
678: case FMAC_IMPORT:
679: fm_import (obj, optc, opts);
680: break;
681:
682:
683: case FMAC_EXPORT:
684: fm_export (obj, optc, opts);
685: break;
686:
687:
688: case FMAC_BACKUP:
689: fm_backup (obj, optc, opts);
690: break;
691:
692:
693: case FMAC_RESTORE:
694: fm_restore (obj, optc, opts);
695: break;
696:
697:
698: case FMAC_MIGRATE:
699: fm_migrate (obj, optc, opts);
700: break;
701:
702:
703: case FMAC_EDIT:
704: fm_edit (obj, optc, opts);
705: break;
706:
707:
708: case FMAC_SET:
709:
710: if (i < 2) {
711: printf ("fmadm: syntax error\n");
712: break;
713: }
714:
715: if (strcmp (args[0], "namespace") == 0) {
716: strcpy (fma_namespace, args[1]);
717:
718: if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
719: fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
720: return 1;
721: }
722:
723: if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
724: fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
725: return 1;
726: }
727:
728: if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
729: fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
730: return 1;
731: }
732:
733: if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
734: fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
735: return 1;
736: }
737:
738: if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
739: strcpy (fma_journal_path, "");
740: }
741:
742: if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
743: strcpy (fma_journal_cut_threshold, "1073741824");
744: }
745:
746: strcpy (gloplib, fma_pct_global_path);
747: stcnv_c2m (gloplib);
748:
749: strcpy (glopath, fma_global_path);
750: stcnv_c2m (glopath);
751:
752: snprintf (fma_prompt, STRLEN - 1, "fmadm [%s]> ", fma_namespace);
753:
754: }
755: else if (strcmp (args[0], "maintenance") == 0) {
756: if (strcmp (args[1], "on") == 0) {
757: shm_config->hdr->maintenance_mode = 1;
758: break;
759: }
760: else if (strcmp (args[1], "off") == 0) {
761: shm_config->hdr->maintenance_mode = 0;
762: break;
763: }
764: else {
765: printf ("fmadm: syntax error\n");
766: }
767:
768: printf ("fmadm: syntax error\n");
769:
770: }
771: else {
772: printf ("fmadm: syntax error\n");
773: break;
774: }
775:
776: break;
777:
778:
779: case FMAC_SHOW:
780: printf ("Namespace: %s\n", fma_namespace);
781: printf ("Routine Path: %s\n", fma_routine_path);
782: printf ("%%-Routine Path: %s\n", fma_pct_routine_path);
783: printf ("Global Path: %s\n", fma_global_path);
784: printf ("%%-Global Path: %s\n", fma_pct_global_path);
785: printf ("Journal File: %s\n", fma_journal_path);
1.5 snw 786: printf ("Journal Cut Threshold: %s bytes\n", fma_journal_cut_threshold);
1.1 snw 787: break;
788:
789: case FMAC_EXIT:
790: fmadm_exit (0);
791: break;
792:
793:
794: default:
795: printf ("fmadm: '%s' is not a valid fmadm command\n", cmdt);
796: break;
797:
798: }
799: }
800:
801: #endif
802:
803: }
804:
805: void fmadm_exit (int retval)
806: {
807: locktab_unlock_all ();
808: job_remove (pid);
809:
810: shm_exit ();
811:
812: exit (retval);
813: }
814:
815: int fmadm_usage (void)
816: {
817:
818: fprintf (stdout, "\nusage: fmadm <action> <object> [-e=<environment] [-n=<namespace>] [OPTIONS]\n");
819: fprintf (stdout, " fmadm configure\n");
820: fprintf (stdout, " fmadm reconfigure\n");
821: /* fprintf (stdout, " fmadm checkperms\n\n"); */
822:
823: fprintf (stdout, " <action> can be one of:\n");
824: fprintf (stdout, " list, examine, verify, compact, repair, create, remove,\n");
825: fprintf (stdout, " import, export, backup, restore, migrate, edit\n\n");
826:
827: fprintf (stdout, " <object> can be one of:\n");
828: fprintf (stdout, " lock, zallocate, journal, namespace, global, routine, job\n\n");
829:
830: fprintf (stdout, " Not all actions are valid for all objects. Please see the FreeM manual\n");
831: fprintf (stdout, " for details on fmadm usage and options.\n\n");
832:
833: return 1;
834:
835: } /* fmadm_usage() */
836:
837: int fm_list (short object, int optc, char **options)
838: {
839:
840: switch (object) {
841:
842: case OBJ_LOCK:
843: return fma_locks_list (optc, options);
844:
845: case OBJ_ROUTINE:
846: return fma_routines_list (optc, options);
847:
848: case OBJ_GLOBAL:
849: return fma_globals_list (optc, options);
850:
851: case OBJ_JOB:
852: return fma_jobs_list (optc, options);
853:
854: default:
855: fprintf (stderr, "fmadm: 'list' is an invalid action for '%s'\n", obj_str);
856: return 1;
857:
858: }
859:
860:
861: } /* fm_list() */
862:
863: int fm_examine (short object, int optc, char **options)
864: {
865:
866: switch (object) {
867:
868: case OBJ_ROUTINE:
869: return fma_routines_examine (optc, options);
870:
871: case OBJ_GLOBAL:
872: return fma_globals_examine (optc, options);
873:
874: case OBJ_JOB:
875: return fma_jobs_examine (optc, options);
876:
877: case OBJ_JOURNAL:
878: return fma_journals_examine (optc, options);
879:
880: default:
881: fprintf (stderr, "fmadm: 'examine' is an invalid action for '%s'\n", obj_str);
882: return 1;
883:
884: }
885:
886: } /* fm_examine() */
887:
888: int fm_verify (short object, int optc, char **options)
889: {
890:
891: switch (object) {
892:
893: case OBJ_GLOBAL:
894: return fma_globals_verify (optc, options);
895:
896: default:
897: fprintf (stderr, "fmadm: 'examine' is an invalid action for '%s'\n", obj_str);
898: return 1;
899:
900: }
901:
902: } /* fm_verify() */
903:
904: int fm_compact (short object, int optc, char **options)
905: {
906:
907: switch (object) {
908:
909: default:
910: fprintf (stderr, "fmadm: 'compact' is an invalid action for '%s'\n", obj_str);
911: return 1;
912:
913: }
914:
915: } /* fm_compact() */
916:
917: int fm_repair (short object, int optc, char **options)
918: {
919:
920: switch (object) {
921:
922: default:
923: fprintf (stderr, "fmadm: 'repair' is an invalid action for '%s'\n", obj_str);
924: return 1;
925:
926: }
927:
928: } /* fm_repair() */
929:
930: int fm_create (short object, int optc, char **options)
931: {
932:
933: switch (object) {
934:
935: default:
936: fprintf (stderr, "fmadm: 'create' is an invalid action for '%s'\n", obj_str);
937: return 1;
938:
939: }
940: } /* fm_create() */
941:
942: int fm_remove (short object, int optc, char **options)
943: {
944:
945: switch (object) {
946:
947: case OBJ_JOB:
948: return fma_jobs_remove (optc, options);
949:
950: case OBJ_LOCK:
951: return fma_locks_remove (optc, options);
952:
953: case OBJ_ROUTINE:
954: return fma_routines_remove (optc, options);
955:
956: case OBJ_GLOBAL:
957: return fma_globals_remove (optc, options);
958:
959: default:
960: fprintf (stderr, "fmadm: 'remove' is an invalid action for '%s'\n", obj_str);
961: return 1;
962:
963: }
964:
965: } /* fm_remove() */
966:
967: int fm_import (short object, int optc, char **options)
968: {
969:
970: switch (object) {
971:
972: case OBJ_ROUTINE:
973: return fma_routines_import (optc, options);
974:
975: default:
976: fprintf (stderr, "fmadm: 'import' is an invalid action for '%s'\n", obj_str);
977: return 1;
978:
979: }
980:
981: } /* fm_import() */
982:
983: int fm_export (short object, int optc, char **options)
984: {
985:
986: switch (object) {
987:
988: case OBJ_ROUTINE:
989: return fma_routines_export (optc, options);
990:
991: default:
992: fprintf (stderr, "fmadm: 'export' is an invalid action for '%s'\n", obj_str);
993: return 1;
994:
995: }
996:
997: } /* fm_export() */
998:
999: int fm_backup (short object, int optc, char **options)
1000: {
1001:
1002: switch (object) {
1003:
1004: case OBJ_ROUTINE:
1005: return fma_routines_backup (optc, options);
1006:
1007: default:
1008: fprintf (stderr, "fmadm: 'backup' is an invalid action for '%s'\n", obj_str);
1009: return 1;
1010:
1011: }
1012:
1013: } /* fm_backup() */
1014:
1015: int fm_restore (short object, int optc, char **options)
1016: {
1017:
1018: switch (object) {
1019:
1020: case OBJ_JOURNAL:
1021: return fma_journals_restore (optc, options);
1022:
1023: default:
1024: fprintf (stderr, "fmadm: 'restore' is an invalid action for '%s'\n", obj_str);
1025: return 1;
1026:
1027: }
1028:
1029: } /* fm_restore() */
1030:
1031: int fm_migrate (short object, int optc, char **options)
1032: {
1033:
1034: switch (object) {
1035:
1036: default:
1037: fprintf (stderr, "fmadm: 'migrate' is an invalid action for '%s'\n", obj_str);
1038: return 1;
1039:
1040: }
1041:
1042: } /* fm_migrate() */
1043:
1044: int fm_edit (short object, int optc, char **options)
1045: {
1046:
1047: switch (object) {
1048:
1049: case OBJ_ROUTINE:
1050: return fma_routines_edit (optc, options);
1051:
1.3 snw 1052: /*
1.1 snw 1053: case OBJ_GLOBAL:
1054: return fma_globals_edit (optc, options);
1.3 snw 1055: */
1.1 snw 1056:
1057: default:
1058: fprintf (stderr, "fmadm: 'edit' is an invalid action for '%s'\n", obj_str);
1059: return 1;
1060:
1061: }
1062:
1063: } /* fm_edit() */
1064:
1065: void fm_checkperms(void)
1066: {
1067:
1068: } /* fm_checkperms() */
1069:
1070:
1071: void fm_reconfigure(void)
1072: {
1073: char config_backup[4096];
1074: char vers[4096];
1075:
1076: int retval;
1077:
1078: if (geteuid () != 0) {
1079: fprintf (stderr, "fmadm: not superuser\n");
1080: exit (1);
1081: }
1082:
1083: snprintf (config_backup, 4095, "%s.orig", config_file);
1084:
1085: fprintf (stderr, "fmadm: reconfiguring FreeM with system defaults for %s...\n", FREEM_VERSION_CSTR);
1086: fprintf (stderr, "fmadm: backing up %s to %s...\t", config_file, config_backup);
1087:
1088: retval = rename (config_file, config_backup);
1089:
1090: if (retval == 0) {
1091: fprintf (stderr, "[OK]\n\n");
1092:
1093: fm_configure ();
1094:
1095: fprintf (stderr, "\n\nYou may wish to edit %s if site-specific changes were made to the original FreeM configuration.\n", config_file);
1096: exit (0);
1097: }
1098: else {
1099: fprintf (stderr, "[FAIL (%s)]\n", strerror (errno));
1100: exit (1);
1101: }
1102:
1103: } /* fm_reconfigure() */
1104:
1105:
1106: void fm_configure (void)
1107: {
1108:
1109: char sysrtn[4096];
1110: char sysgbl[4096];
1111: char usrrtn[4096];
1112: char usrgbl[4096];
1113:
1114: char locktab[4096];
1115: char zalloctab[4096];
1116: char jnlfile[4096];
1117: char jnlmode[4];
1118: char jnlhostid[4096];
1119: char jnlcut[4096];
1120: char hostid[4096];
1121:
1122: char confbase[4096];
1123: char envbase[4096];
1124:
1125: char nsbase[4096];
1126:
1127: char buf[4096];
1128: FILE *fp;
1129:
1130: struct stat etcstat;
1131: int stat_result;
1132:
1133: snprintf (sysrtn, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
1134: snprintf (sysgbl, 4095, "%s/freem/%s/SYSTEM/globals", LOCALSTATEDIR, fma_environment);
1135: snprintf (usrrtn, 4095, "%s/freem/%s/USER/routines", LOCALSTATEDIR, fma_environment);
1136: snprintf (usrgbl, 4095, "%s/freem/%s/USER/globals", LOCALSTATEDIR, fma_environment);
1137: snprintf (locktab, 4095, "/tmp/locktab");
1138: snprintf (zalloctab, 4095, "/tmp/zalloctab");
1139: snprintf (jnlfile, 4095, "/tmp/freem_journal_%s.dat", fma_environment);
1140: snprintf (jnlmode, 3, "on");
1141: snprintf (jnlhostid, 4095, "DEFAULT");
1142: snprintf (jnlcut, 4095, "4294967000");
1143:
1144: if (geteuid () != 0) {
1145: fprintf (stderr, "fmadm: not superuser\n");
1146: exit (1);
1147: }
1148:
1149: if (file_exists (config_file)) {
1150: fprintf (stderr, "fmadm: '%s' already exists.\n\n", config_file);
1151: fprintf (stderr, "'fmadm configure' may only be used on a fresh installation of FreeM.\n");
1152: exit (1);
1153: }
1154:
1155:
1156: gethostname (hostid, 4095);
1157: uuid_v4 (buf);
1158:
1159: snprintf (jnlhostid, 4095, "%s:%s", hostid, buf);
1160:
1161: snprintf (confbase, 4095, "%s/freem", SYSCONFDIR);
1162: snprintf (envbase, 4095, "%s/freem/%s", SYSCONFDIR, fma_environment);
1163: snprintf (nsbase, 4095, "%s/freem/%s", LOCALSTATEDIR, fma_environment);
1164:
1.9 snw 1165: #if defined(__OS2__)
1166: {
1167: char srcfile[PATHLEN];
1.11 snw 1168: char dstfile[PATHLEN];
1169:
1.9 snw 1170: snprintf (srcfile, PATHLEN, "%s/bin/freem.exe", PREFIX);
1171: snprintf (dstfile, PATHLEN, "%s/bin/freemd.exe", PREFIX);
1.11 snw 1172:
1173: unlink (dstfile);
1.9 snw 1174:
1.10 snw 1175: fprintf (stderr, "fmadm: running on OS/2; will copy %s to %s\n", srcfile, dstfile);
1.12 snw 1176:
1.16 ! snw 1177: if (DosCopy (srcfile, dstfile, 1) != 0) {
1.9 snw 1178: fprintf (stderr, "fmadm: fatal error copying %s to %s\n", srcfile, dstfile);
1179: exit (1);
1180: }
1.13 snw 1181:
1182: chmod (dstfile, 0755);
1.9 snw 1183: }
1184: #else
1185: fprintf (stderr, "fmadm: not running on OS/2\n");
1186: #endif
1187:
1.1 snw 1188: printf ("\nFreeM Initial Configuration\n");
1189: printf ("---------------------------\n\n");
1190:
1191: printf ("This utility will create the initial configuration file for ");
1192: printf ("FreeM environment '%s' in %s.\n\n", fma_environment, config_file);
1.9 snw 1193:
1.1 snw 1194: /* check for existence of needed directories */
1195: if (stat (SYSCONFDIR, &etcstat) == -1) {
1196: fprintf (stderr, "fmadm: creating %s\n", SYSCONFDIR);
1197: mkdir (SYSCONFDIR, 0755);
1198: }
1199:
1200: if (stat (confbase, &etcstat) == -1) {
1201: fprintf (stderr, "fmadm: creating %s\n", confbase);
1202: mkdir (confbase, 0755);
1203: }
1204:
1205: if (stat (envbase, &etcstat) == -1) {
1206: fprintf (stderr, "fmadm: creating %s\n", envbase);
1207: mkdir (envbase, 0755);
1208: }
1209:
1210: if (stat (nsbase, &etcstat) == -1) {
1211: fprintf (stderr, "fmadm: creating %s\n", nsbase);
1212: mkdir (nsbase, 0755);
1213: }
1214:
1215:
1216:
1217: if (strcmp (fma_environment, "DEFAULT") != 0) {
1218:
1219: DIR *dir;
1220: struct dirent *ent;
1221: char src_dir[4096];
1222: char dest_dir[4096];
1223:
1224: snprintf (src_dir, 4095, "%s/freem/DEFAULT/SYSTEM/routines", LOCALSTATEDIR);
1225: snprintf (dest_dir, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
1226:
1227: fprintf (stderr, "fmadm: populating new environment '%s'\n", fma_environment);
1228:
1229: snprintf (buf, 4095, "%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
1230: mkdir (buf, 0755);
1231:
1232: snprintf (buf, 4095, "%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
1233: mkdir (buf, 0755);
1234:
1235: snprintf (buf, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
1236: mkdir (buf, 0755);
1237:
1238: snprintf (buf, 4095, "%s/freem/%s/USER/globals", LOCALSTATEDIR, fma_environment);
1239: mkdir (buf, 0755);
1240:
1241: snprintf (buf, 4095, "%s/freem/%s/SYSTEM/globals", LOCALSTATEDIR, fma_environment);
1242: mkdir (buf, 0755);
1243:
1244: snprintf (buf, 4095, "%s/freem/%s/USER/routines", LOCALSTATEDIR, fma_environment);
1245: mkdir (buf, 0755);
1246:
1247: fprintf (stderr, "fmadm: copying routines from '%s' to '%s'...\n", src_dir, dest_dir);
1248:
1249: if ((dir = opendir (src_dir)) == NULL) {
1250: fprintf (stderr, "\nfmadm: could not open source directory %s\n", src_dir);
1251: exit (1);
1252: }
1253:
1254: while ((ent = readdir (dir)) != NULL) {
1255: char infile[4096];
1256: char outfile[4096];
1257:
1258: if ((strcmp (ent->d_name, ".") != 0) && (strcmp (ent->d_name, "..") != 0)) {
1259:
1260: fprintf (stderr, "\t%s\n", ent->d_name);
1261:
1262: snprintf (infile, 4095, "%s/%s", src_dir, ent->d_name);
1263: snprintf (outfile, 4095, "%s/%s", dest_dir, ent->d_name);
1264:
1265: if (cp (outfile, infile) != 0) {
1266: fprintf (stderr, "fmadm: failure copying %s to %s\n", infile, outfile);
1267: }
1268:
1269: }
1270:
1271: }
1272:
1273:
1274: }
1275:
1276:
1277: fp = fopen (config_file, "a+");
1278:
1279:
1280: printf ("Creating %s... ", config_file);
1281:
1282: snprintf (buf, 4095, "[SYSTEM]");
1283: fm_write (fp, buf);
1284:
1285: snprintf (buf, 4095, "root=%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
1286: fm_write (fp, buf);
1287:
1288: snprintf (buf, 4095, "routines_path=%s", sysrtn);
1289: fm_write (fp, buf);
1290:
1291: snprintf (buf, 4095, "globals_path=%s", sysgbl);
1292: fm_write (fp, buf);
1293:
1294: snprintf (buf, 4095, "journal_file=%s", jnlfile);
1295: fm_write (fp, buf);
1296:
1297: snprintf (buf, 4095, "journal_mode=%s", jnlmode);
1298: fm_write (fp, buf);
1299:
1300: snprintf (buf, 4095, "journal_host_id=%s", jnlhostid);
1301: fm_write (fp, buf);
1302:
1303: snprintf (buf, 4095, "journal_cut_threshold=%s", jnlcut);
1304: fm_write (fp, buf);
1305:
1306: snprintf (buf, 4095, "zdate_format=%%x");
1307: fm_write (fp, buf);
1308:
1309: snprintf (buf, 4095, "ztime_format=%%X");
1310: fm_write (fp, buf);
1311:
1312: snprintf (buf, 4095, "\n[USER]");
1313: fm_write (fp, buf);
1314:
1315: snprintf (buf, 4095, "root=%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
1316: fm_write (fp, buf);
1317:
1318: snprintf (buf, 4095, "routines_path=%s", usrrtn);
1319: fm_write (fp, buf);
1320:
1321: snprintf (buf, 4095, "globals_path=%s", usrgbl);
1322: fm_write (fp, buf);
1323:
1324:
1325: fclose (fp);
1326:
1327: printf ("[OK]\n\n");
1328:
1329: /*
1330: printf ("Setting USER namespace permissions... ");
1331:
1332: snprintf (buf, 4095, "%s/freem/USER/globals", LOCALSTATEDIR);
1333: chmod (buf, 0777);
1334:
1335: snprintf (buf, 4095, "%s/freem/USER/routines", LOCALSTATEDIR);
1336: chmod (buf, 0777);
1337:
1338: printf ("[OK]\n");
1339: printf ("Setting SYSTEM namespace permissions... ");
1340:
1341: snprintf (buf, 4095, "%s/freem/SYSTEM/globals", LOCALSTATEDIR);
1342: chmod (buf, 0755);
1343:
1344: snprintf (buf, 4095, "%s/freem/SYSTEM/routines", LOCALSTATEDIR);
1345: chmod (buf, 0755);
1346:
1347: printf ("[OK]\n\n\n");
1348: */
1349: printf ("FreeM initial configuration is complete.\n\n");
1350:
1351: printf (" USER globals: %s\n", usrgbl);
1352: printf (" USER routines: %s\n", usrrtn);
1353: printf (" SYSTEM globals: %s\n", sysgbl);
1354: printf (" SYSTEM routines: %s\n", sysrtn);
1355: printf (" After-image journal: %s [%s]\n", jnlfile, jnlmode);
1356: printf (" Journal cut threshold: %s bytes\n", jnlcut);
1357: printf (" Distributed journaling host ID: %s\n", jnlhostid);
1358:
1359:
1360: } /* fm_configure */
1361:
1362: void fm_write (FILE *file, char *buf)
1363: {
1364: fprintf (file, "%s\n", buf);
1365: }
1366:
1367: void fm_sig_attach (int sig, void *handler)
1368: {
1369: struct sigaction act;
1370:
1371: act.sa_handler = handler;
1372: sigaction (sig, &act, NULL);
1373:
1374: }
1375:
1376: void fm_sig_init (void)
1377: {
1378: sig_attach (SIGINT, &fm_on_sigint);
1379: sig_attach (SIGTERM, &fm_on_sigterm);
1380: }
1381:
1382: void fm_on_sigint (void)
1383: {
1384: fprintf (stderr, "\nfmadm: caught SIGINT\n");
1385: fmadm_exit (0);
1386: }
1387:
1388: void fm_on_sigterm (void)
1389: {
1390: fprintf (stderr, "\nfmadm: caught SIGTERM\n");
1391: fmadm_exit (0);
1392: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fmadm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src