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