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