Annotation of freem/src/fmadm.c, revision 1.29
1.1 snw 1: /*
1.29 ! snw 2: * $Id: fmadm.c,v 1.28 2025/04/02 19:59:38 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.29 ! snw 27: * Revision 1.28 2025/04/02 19:59:38 snw
! 28: * Automatically modify env.conf from fmadm reconfigure
! 29: *
1.28 snw 30: * Revision 1.27 2025/04/02 15:36:25 snw
31: * Do extensive result checking for environment stop/start/restart in fmadm
32: *
1.27 snw 33: * Revision 1.26 2025/04/02 14:37:57 snw
34: * Improve environment control parts of fmadm
35: *
1.26 snw 36: * Revision 1.25 2025/04/02 04:50:49 snw
37: * Allow vendor routines to be upgraded
38: *
1.25 snw 39: * Revision 1.24 2025/04/02 03:02:42 snw
40: * Stop requiring users to pass -e to fmadm when -u or -g are passed
41: *
1.24 snw 42: * Revision 1.23 2025/04/02 02:16:27 snw
43: * Add fmadm status environment command and move journals to a better location
44: *
1.23 snw 45: * Revision 1.22 2025/04/01 23:21:45 snw
46: * fmadm commands for stopping, starting, and restarting environments now functional
47: *
1.22 snw 48: * Revision 1.21 2025/04/01 20:11:46 snw
49: * Further work on fmadm
50: *
1.21 snw 51: * Revision 1.20 2025/04/01 16:37:12 snw
52: * Configure DEFAULT environment the same as others, and set permissions/ownership directly in fmadm configure. Add env.conf file as a centralized configuration listing all environments.
53: *
1.20 snw 54: * Revision 1.19 2025/04/01 14:32:11 snw
55: * Begin work on environment and namespace reorg
56: *
1.19 snw 57: * Revision 1.18 2025/03/31 16:33:56 snw
58: * Work on fmadm edit global
59: *
1.18 snw 60: * Revision 1.17 2025/03/30 01:36:58 snw
61: * Make it easier to bring back fma_gedit, fix double-free in global handler, limit $CHAR to 7-bit ASCII
62: *
1.17 snw 63: * Revision 1.16 2025/03/24 20:59:58 snw
64: * Try using DosCopy API instead of built-in cp function on OS/2
65: *
1.16 snw 66: * Revision 1.15 2025/03/24 20:58:05 snw
67: * Try using DosCopy API instead of built-in cp function on OS/2
68: *
1.15 snw 69: * Revision 1.14 2025/03/24 20:57:06 snw
70: * Try using DosCopy API instead of built-in cp function on OS/2
71: *
1.14 snw 72: * Revision 1.13 2025/03/24 20:15:09 snw
73: * Set file permissions on freemd.exe on OS/2 in fmadm configure
74: *
1.13 snw 75: * Revision 1.12 2025/03/24 20:13:34 snw
76: * Set file permissions on freemd.exe on OS/2 in fmadm configure
77: *
1.12 snw 78: * Revision 1.11 2025/03/24 19:25:48 snw
79: * Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
80: *
1.11 snw 81: * Revision 1.10 2025/03/24 19:22:16 snw
82: * Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
83: *
1.10 snw 84: * Revision 1.9 2025/03/24 19:19:42 snw
85: * Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
86: *
1.9 snw 87: * Revision 1.8 2025/03/22 18:43:54 snw
88: * Make STRLEN 255 chars and add BIGSTR macro for larger buffers
89: *
1.8 snw 90: * Revision 1.7 2025/03/09 19:14:25 snw
91: * First phase of REUSE compliance and header reformat
92: *
1.7 snw 93: *
94: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
95: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 96: **/
97:
98: #include <sys/types.h>
99: #include <sys/stat.h>
1.19 snw 100: #include <pwd.h>
101: #include <grp.h>
1.1 snw 102: #include <stddef.h>
103: #include <stdio.h>
104: #include <string.h>
105: #include <dirent.h>
106: #include <stdlib.h>
107: #include <unistd.h>
108: #include <errno.h>
1.4 snw 109: #include <ctype.h>
1.1 snw 110: #include "config.h"
111: #include "transact.h"
112: #include "namespace.h"
113: #include "fs.h"
114:
1.14 snw 115: #if defined(__OS2__)
116: # include <os2.h>
117: #endif
118:
1.1 snw 119: #ifdef HAVE_LIBREADLINE
120: # if defined(HAVE_READLINE_READLINE_H)
121: # include <readline/readline.h>
122: # elif defined(HAVE_READLINE_H)
123: # include <readline.h>
124: # else /* !defined(HAVE_READLINE_H) */
125: extern char *readline ();
126: # endif /* !defined(HAVE_READLINE_H) */
127: /*char *cmdline = NULL;*/
128: #else /* !defined(HAVE_READLINE_READLINE_H) */
129: /* no readline */
130: #endif /* HAVE_LIBREADLINE */
131:
132: #ifdef HAVE_READLINE_HISTORY
133: # if defined(HAVE_READLINE_HISTORY_H)
134: # include <readline/history.h>
135: # elif defined(HAVE_HISTORY_H)
136: # include <history.h>
137: # else /* !defined(HAVE_HISTORY_H) */
138: extern void add_history ();
139: extern int write_history ();
140: extern int read_history ();
141: # endif /* defined(HAVE_READLINE_HISTORY_H) */
142: /* no history */
143: #endif /* HAVE_READLINE_HISTORY */
144:
145:
146: #include "fmadm.h"
147: #include "errmsg.h"
148: #include "iniconf.h"
149: #include "init.h"
150: #include "version.h"
151: #include "shmmgr.h"
152: #include "jobtab.h"
153: #include "locktab.h"
154:
155: /* namespace configuration */
156: char fma_environment[STRLEN];
157: char fma_namespace[STRLEN];
1.8 snw 158: char fma_routine_path[PATHLEN];
159: char fma_global_path[PATHLEN];
160: char fma_journal_path[PATHLEN];
161: char fma_pct_global_path[PATHLEN];
162: char fma_pct_routine_path[PATHLEN];
1.1 snw 163: char fma_journal_cut_threshold[STRLEN];
1.8 snw 164: char fma_locktab[PATHLEN];
1.1 snw 165: short fma_base_opt = 1;
166: short fma_min_args = 2;
167: short fma_explicit_namespace = FALSE;
168: short fma_explicit_environment = FALSE;
169:
170: /* miscellaneous global state */
171: char obj_str[STRLEN];
172:
173: extern char config_file[4096];
1.20 snw 174: extern char env_config_file[4096];
175: extern char env_user[255];
176: extern char env_group[255];
1.29 ! snw 177: extern char env_enabled[10];
1.1 snw 178:
179: int fm_shell(void);
180: void fm_checkperms(void);
181: void fm_reconfigure(void);
182: void fm_configure(void);
1.21 snw 183: int fm_daemonctl (short action, short object, int optc, char **options);
1.1 snw 184: void fm_write (FILE *file, char *buf);
185: int fma_jobs_remove (int optc, char **opts);
1.20 snw 186: void set_permissions(char *path, char *user, char *grp, int mode);
1.27 snw 187: int fm_environment_running (char *env);
1.21 snw 188: extern int read_profile_string(char *file, char *section, char *key, char *value);
1.1 snw 189:
190: int main (int argc, char **argv)
191: {
192: char action[STRLEN];
193:
194: short act = -1;
195: short obj = -1;
196:
197: char **opts;
198: int optc = argc - 3;
199:
200: int i = 0;
201: int j = 1;
202: int base_arg = 4;
203: int k = 0;
204:
205: short got_action = FALSE;
206: short got_object = FALSE;
207:
1.29 ! snw 208: strcpy (env_enabled, "true");
1.1 snw 209:
210: /* snprintf (config_file, 4096, "%s/freem.conf", SYSCONFDIR); */
211:
212: base_arg = 1;
213:
214: /* enforce action in argv[1] */
215: if (argc > 1) {
216: if (argv[1][0] == '-') {
217: fprintf (stderr, "fmadm: first argument, if given, must be an action, not a flag\n");
218: fmadm_usage ();
219: exit (1);
220: }
221: }
222:
223: for (i = base_arg; i < argc; i++) {
224: if (i == 1 && isalpha (argv[i][0])) {
225: got_action = TRUE;
226: strncpy (action, argv[i], STRLEN - 1);
227: base_arg++;
228: }
229: if (i == 2 && isalpha (argv[i][0])) {
230: got_object = TRUE;
231: strncpy (obj_str, argv[i], STRLEN - 1);
232: base_arg++;
233: }
234: if (argv[i][0] == '-') {
235:
236: switch (argv[i][1]) {
1.20 snw 237:
238: case 'u':
239: if (argv[i][2] != '=') {
240: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
241: fmadm_usage ();
242: exit (1);
243: }
244:
245: k = 0;
246:
247: for (j = 3; j < strlen (argv[i]); j++) {
248: env_user[k++] = argv[i][j];
249: }
250:
251: base_arg++;
252:
253: break;
254:
255: case 'g':
256: if (argv[i][2] != '=') {
257: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
258: fmadm_usage ();
259: exit (1);
260: }
261:
262: k = 0;
263:
264: for (j = 3; j < strlen (argv[i]); j++) {
265: env_group[k++] = argv[i][j];
266: }
267:
268: base_arg++;
269:
270: break;
271:
1.1 snw 272:
273: case 'e':
274: if (argv[i][2] != '=') {
275: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
276: fmadm_usage ();
277: exit (1);
278: }
279:
280: k = 0;
281:
282: for (j = 3; j < strlen (argv[i]); j++) {
283: fma_environment[k++] = argv[i][j];
284: }
1.21 snw 285:
286: if (strcmp (fma_environment, "all") == 0 ) {
287: fprintf (stderr, "fmadm: 'all' is an invalid environment name\n");
288: exit (1);
289: }
1.1 snw 290:
291: fma_explicit_environment = TRUE;
292: base_arg++;
293:
294: break;
1.29 ! snw 295:
! 296: case 'E':
! 297: if (argv[i][2] != '=') {
! 298: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
! 299: fmadm_usage ();
! 300: exit (1);
! 301: }
! 302:
! 303: k = 0;
! 304:
! 305: for (j = 3; j < strlen (argv[i]); j++) {
! 306: env_enabled[k++] = argv[i][j];
! 307: }
! 308: env_enabled[k] = '\0';
! 309:
! 310: if ((strcmp (env_enabled, "true") != 0) && (strcmp (env_enabled, "false") != 0)) {
! 311: fprintf (stderr, "fmadm: -E (environment enabled) option must be either 'true' or 'false'\n");
! 312: fmadm_usage ();
! 313: exit (1);
! 314: }
! 315:
! 316: base_arg++;
! 317:
! 318: break;
! 319:
1.1 snw 320:
321: case 'n':
322: if (argv[i][2] != '=') {
323: fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
324: fmadm_usage ();
325: exit (1);
326: }
327:
328: k = 0;
329:
330: for (j = 3; j < strlen (argv[i]); j++) {
331: fma_namespace[k++] = argv[i][j];
332: }
333:
334: fma_explicit_namespace = TRUE;
335: base_arg++;
336:
337: break;
338:
339: }
340: }
341: }
1.24 snw 342:
1.21 snw 343: if (obj != OBJ_DAEMON) {
344: if (strlen (env_user) == 0) {
345: snprintf (env_user, 6, "freem");
346: }
347:
348: if (strlen (env_group) == 0) {
349: snprintf (env_group, 6, "freem");
350: }
1.20 snw 351:
1.1 snw 352:
1.21 snw 353: if (!fma_explicit_environment) snprintf (fma_environment, 4096, "DEFAULT");
354: if (!fma_explicit_namespace) snprintf (fma_namespace, 4096, "SYSTEM");
355:
356: snprintf (config_file, 4096, "%s/freem/%s/freem.conf", SYSCONFDIR, fma_environment);
357: }
1.1 snw 358:
1.20 snw 359: snprintf (env_config_file, 4096, "%s/freem/env.conf", SYSCONFDIR);
360:
1.26 snw 361: /*
1.1 snw 362: 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]);
363: exit(1);
1.26 snw 364: */
1.1 snw 365:
1.21 snw 366: /* override for fmadm configure and daemon stuff */
1.1 snw 367: if (got_action) {
368: if (strcmp (argv[1], "configure") == 0) {
369: fm_configure ();
370: exit (0);
371: }
372: else if (strcmp (argv[1], "reconfigure") == 0) {
373: fm_reconfigure ();
374: exit (0);
375: }
1.21 snw 376: else if (strcmp (argv[1], "start") == 0 && strcmp (argv[2], "environment") == 0) {
377: act = ACT_START;
378: obj = OBJ_DAEMON;
1.26 snw 379: goto process_args;
1.21 snw 380: }
381: else if (strcmp (argv[1], "stop") == 0 && strcmp (argv[2], "environment") == 0) {
382: act = ACT_STOP;
383: obj = OBJ_DAEMON;
1.26 snw 384: goto process_args;
1.21 snw 385: }
386: else if (strcmp (argv[1], "restart") == 0 && strcmp (argv[2], "environment") == 0) {
387: act = ACT_RESTART;
388: obj = OBJ_DAEMON;
1.26 snw 389: goto process_args;
1.23 snw 390: }
391: else if (strcmp (argv[1], "status") == 0 && strcmp (argv[2], "environment") == 0) {
392: act = ACT_STATUS;
393: obj = OBJ_DAEMON;
1.26 snw 394: goto process_args;
1.21 snw 395: }
1.23 snw 396:
1.1 snw 397: }
398:
399: pid = getpid ();
400:
401: shm_init (16777216);
402: tp_init ();
403: jobtab_init ();
404: job_init (TRUE);
405:
406: fm_sig_init ();
1.21 snw 407:
1.1 snw 408: /* go to fmadm shell if no arguments passed */
409: if (!got_action && !got_object) return fm_shell ();
410:
411: if (argc > 1 && strcmp (argv[1], "checkperms") == 0) {
412: fm_checkperms ();
413: exit (0);
414: }
415:
416: set_namespace (fma_namespace, FALSE);
1.26 snw 417:
418: process_args:
1.1 snw 419: /* allocate opts array */
420:
421: /* first dimension */
422: if ((opts = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
423: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
424: return 1;
425: }
426:
427: /* second dimension */
428: for (i = 0; i < FMA_MAXARGS; i++) {
429: if ((opts[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
430: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
431: return 1;
432: }
433: }
434:
435: /* copy argv[base_arg] through argv[argc - 1] to opts[1] through opts[argc - 3] */
436:
437: strncpy (opts[0], argv[0], STRLEN - 1); /* preserve argv[0] */
438:
439: j = 1;
440: for (i = base_arg; i < argc; i++) {
1.26 snw 441: if (i > FMA_MAXARGS) return fmadm_usage();
442: /* bail if we're going to overrun the array */
1.1 snw 443: strncpy (opts[j++], argv[i], STRLEN - 1);
444: }
445:
446: if (strncmp (action, "list", STRLEN - 1) == 0) act = ACT_LIST;
447: else if (strncmp (action, "examine", STRLEN - 1) == 0) act = ACT_EXAMINE;
448: else if (strncmp (action, "verify", STRLEN - 1) == 0) act = ACT_VERIFY;
449: else if (strncmp (action, "compact", STRLEN - 1) == 0) act = ACT_COMPACT;
450: else if (strncmp (action, "repair", STRLEN - 1) == 0) act = ACT_REPAIR;
451: else if (strncmp (action, "create", STRLEN - 1) == 0) act = ACT_CREATE;
452: else if (strncmp (action, "remove", STRLEN - 1) == 0) act = ACT_REMOVE;
453: else if (strncmp (action, "import", STRLEN - 1) == 0) act = ACT_IMPORT;
454: else if (strncmp (action, "export", STRLEN - 1) == 0) act = ACT_EXPORT;
455: else if (strncmp (action, "backup", STRLEN - 1) == 0) act = ACT_BACKUP;
456: else if (strncmp (action, "restore", STRLEN - 1) == 0) act = ACT_RESTORE;
457: else if (strncmp (action, "migrate", STRLEN - 1) == 0) act = ACT_MIGRATE;
1.21 snw 458: else if (strncmp (action, "edit", STRLEN - 1) == 0) act = ACT_EDIT;
459: else if (strncmp (action, "start", STRLEN - 1) == 0) act = ACT_START;
460: else if (strncmp (action, "stop", STRLEN - 1) == 0) act = ACT_STOP;
461: else if (strncmp (action, "restart", STRLEN - 1) == 0) act = ACT_RESTART;
1.26 snw 462: else if (strncmp (action, "status", STRLEN - 1) == 0) act = ACT_STATUS;
1.1 snw 463: else return fmadm_usage();
464:
465: if (strncmp (obj_str, "lock", STRLEN - 1) == 0) obj = OBJ_LOCK;
466: else if (strncmp (obj_str, "journal", STRLEN - 1) == 0) obj = OBJ_JOURNAL;
467: else if (strncmp (obj_str, "namespace", STRLEN - 1) == 0) obj = OBJ_NAMESPACE;
468: else if (strncmp (obj_str, "global", STRLEN - 1) == 0) obj = OBJ_GLOBAL;
469: else if (strncmp (obj_str, "routine", STRLEN - 1) == 0) obj = OBJ_ROUTINE;
470: else if (strncmp (obj_str, "job", STRLEN - 1) == 0) obj = OBJ_JOB;
1.21 snw 471: else if (strncmp (obj_str, "environment", STRLEN - 1) == 0) obj = OBJ_DAEMON;
1.1 snw 472: else return fmadm_usage();
473:
1.21 snw 474: if (act > ACT_EDIT) goto act_switch;
475:
1.1 snw 476: if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
477: fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
478: return 1;
479: }
480:
481: if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
482: fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
483: return 1;
484: }
485:
486: if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
487: fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
488: return 1;
489: }
490:
491: if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
492: fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
493: return 1;
494: }
495:
496: if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
497: strcpy (fma_journal_path, "");
498: }
499:
500: if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
501: strcpy (fma_journal_cut_threshold, "1073741824");
502: }
503:
504: strcpy (gloplib, fma_pct_global_path);
505: stcnv_c2m (gloplib);
506:
507: strcpy (glopath, fma_global_path);
508: stcnv_c2m (glopath);
509:
510:
1.21 snw 511: act_switch:
1.1 snw 512: switch (act) {
513:
514:
515: case ACT_LIST:
516: fmadm_exit (fm_list (obj, optc, opts));
517:
518:
519: case ACT_EXAMINE:
520: fmadm_exit (fm_examine (obj, optc, opts));
521:
522:
523: case ACT_VERIFY:
524: fmadm_exit (fm_verify (obj, optc, opts));
525:
526:
527: case ACT_COMPACT:
528: fmadm_exit (fm_compact (obj, optc, opts));
529:
530:
531: case ACT_REPAIR:
532: fmadm_exit (fm_repair (obj, optc, opts));
533:
534:
535: case ACT_CREATE:
536: fmadm_exit (fm_create (obj, optc, opts));
537:
538:
539: case ACT_REMOVE:
540: fmadm_exit (fm_remove (obj, optc, opts));
541:
542:
543: case ACT_IMPORT:
544: fmadm_exit (fm_import (obj, optc, opts));
545:
546:
547: case ACT_EXPORT:
548: fmadm_exit (fm_export (obj, optc, opts));
549:
550:
551: case ACT_BACKUP:
552: fmadm_exit (fm_backup (obj, optc, opts));
553:
554:
555: case ACT_RESTORE:
556: fmadm_exit (fm_restore (obj, optc, opts));
557:
558:
559: case ACT_MIGRATE:
560: fmadm_exit (fm_migrate (obj, optc, opts));
561:
562:
563: case ACT_EDIT:
564: fmadm_exit (fm_edit (obj, optc, opts));
565:
1.21 snw 566: case ACT_START:
567: case ACT_STOP:
568: case ACT_RESTART:
1.23 snw 569: case ACT_STATUS:
1.21 snw 570: fmadm_exit (fm_daemonctl (act, obj, optc, opts));
1.1 snw 571:
572: default:
573: return fmadm_usage();
574: }
575:
576: return 0; /* should never be reached */
577:
578: } /* main() */
579:
580: int fm_shell (void)
581: {
582:
583: #if defined(HAVE_LIBREADLINE) && !defined(_AIX)
584: int cmd;
585: int i;
586: int j;
587: int obj;
588: int optc;
589: int argc;
590: char **args;
591: char **opts;
592: char *fmarl_buf;
593: char *fma_prompt = (char *) malloc (STRLEN * sizeof (char));
594: char *cmdt = (char *) malloc (65535 * sizeof (char));
595: char *result = (char *) malloc (65535 * sizeof (char));
596:
597: /*
598: strcpy (fma_namespace, "SYSTEM");
599: set_namespace (fma_namespace, FALSE);
600: */
601:
602: snprintf (fma_prompt, STRLEN - 1, "fmadm [%s]> ", fma_namespace);
603:
604: if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
605: fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
606: return 1;
607: }
608:
609: if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
610: fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
611: return 1;
612: }
613:
614: if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
615: fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
616: return 1;
617: }
618:
619: if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
620: fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
621: return 1;
622: }
623:
624: if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
625: strcpy (fma_journal_path, "");
626: }
627:
628: if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
629: strcpy (fma_journal_cut_threshold, "1073741824");
630: }
631:
632: strcpy (gloplib, fma_pct_global_path);
633: stcnv_c2m (gloplib);
634:
635: strcpy (glopath, fma_global_path);
636: stcnv_c2m (glopath);
637:
638: /* allocate args array */
639:
640: /* first dimension */
641: if ((args = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
642: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
643: return 1;
644: }
645:
646: /* second dimension */
647: for (i = 0; i < FMA_MAXARGS; i++) {
648: if ((args[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
649: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
650: return 1;
651: }
652: }
653:
654: /* allocate opts array */
655:
656: /* first dimension */
657: if ((opts = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
658: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
659: return 1;
660: }
661:
662: /* second dimension */
663: for (i = 0; i < FMA_MAXARGS; i++) {
664: if ((opts[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
665: fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
666: return 1;
667: }
668: }
669:
670:
671: for (;;) {
672:
673: fmarl_buf = readline (fma_prompt);
674:
675: if (fmarl_buf == (char *) NULL) continue;
676:
677: cmdt = strtok (fmarl_buf, " ");
678:
1.2 snw 679: if (cmdt == (char *) NULL) continue;
680:
1.1 snw 681: for (i = 0; i < strlen (cmdt); i++) cmdt[i] = cmdt[i] | 0140;
682:
683: if (strcmp (cmdt, "exit") == 0) cmd = FMAC_EXIT;
684: else if (strcmp (cmdt, "quit") == 0) cmd = FMAC_EXIT;
685: else if (strcmp (cmdt, "select") == 0) cmd = FMAC_SELECT;
686: else if (strcmp (cmdt, "list") == 0) cmd = FMAC_LIST;
687: else if (strcmp (cmdt, "examine") == 0) cmd = FMAC_EXAMINE;
688: else if (strcmp (cmdt, "verify") == 0) cmd = FMAC_VERIFY;
689: else if (strcmp (cmdt, "compact") == 0) cmd = FMAC_COMPACT;
690: else if (strcmp (cmdt, "repair") == 0) cmd = FMAC_REPAIR;
691: else if (strcmp (cmdt, "create") == 0) cmd = FMAC_CREATE;
692: else if (strcmp (cmdt, "import") == 0) cmd = FMAC_IMPORT;
693: else if (strcmp (cmdt, "export") == 0) cmd = FMAC_EXPORT;
694: else if (strcmp (cmdt, "backup") == 0) cmd = FMAC_BACKUP;
695: else if (strcmp (cmdt, "restore") == 0) cmd = FMAC_RESTORE;
696: else if (strcmp (cmdt, "migrate") == 0) cmd = FMAC_MIGRATE;
697: else if (strcmp (cmdt, "edit") == 0) cmd = FMAC_EDIT;
698: else if (strcmp (cmdt, "set") == 0) cmd = FMAC_SET;
699: else if (strcmp (cmdt, "show") == 0) cmd = FMAC_SHOW;
700: else if (strcmp (cmdt, "remove") == 0) cmd = FMAC_REMOVE;
701: else cmd = FMAC_INVALID;
702:
703: i = 0;
704: while ((result = strtok (NULL, " ")) != NULL) {
705: // printf ("%d = %s\n", i, result);
706: strcpy (args[i++], result);
707: }
708:
709: argc = i;
710: j = 0;
711:
712: for (i = 1; i < argc; i++) {
713: strncpy (opts[j++], args[i], STRLEN - 1);
714: }
715:
716: optc = argc - 1;
717:
718: if (i > 0) {
719:
720: strcpy (obj_str, args[0]);
721:
722: if (strncmp (obj_str, "lock", STRLEN - 1) == 0) obj = OBJ_LOCK;
723: else if (strncmp (obj_str, "journal", STRLEN - 1) == 0) obj = OBJ_JOURNAL;
724: else if (strncmp (obj_str, "namespace", STRLEN - 1) == 0) obj = OBJ_NAMESPACE;
725: else if (strncmp (obj_str, "global", STRLEN - 1) == 0) obj = OBJ_GLOBAL;
726: else if (strncmp (obj_str, "routine", STRLEN - 1) == 0) obj = OBJ_ROUTINE;
727: else if (strncmp (obj_str, "job", STRLEN - 1) == 0) obj = OBJ_JOB;
728:
729: }
730:
731: switch (cmd) {
732:
733:
734: case FMAC_SELECT:
735:
736:
737: break;
738:
739:
740: case FMAC_LIST:
741: fm_list (obj, optc, opts);
742: break;
743:
744:
745: case FMAC_EXAMINE:
746: fm_examine (obj, optc, opts);
747: break;
748:
749:
750: case FMAC_VERIFY:
751: fm_verify (obj, optc, opts);
752: break;
753:
754:
755: case FMAC_COMPACT:
756: fm_compact (obj, optc, opts);
757: break;
758:
759:
760: case FMAC_REPAIR:
761: fm_repair (obj, optc, opts);
762: break;
763:
764:
765: case FMAC_CREATE:
766: fm_create (obj, optc, opts);
767: break;
768:
769:
770: case FMAC_REMOVE:
771: fm_remove (obj, optc, opts);
772: break;
773:
774:
775: case FMAC_IMPORT:
776: fm_import (obj, optc, opts);
777: break;
778:
779:
780: case FMAC_EXPORT:
781: fm_export (obj, optc, opts);
782: break;
783:
784:
785: case FMAC_BACKUP:
786: fm_backup (obj, optc, opts);
787: break;
788:
789:
790: case FMAC_RESTORE:
791: fm_restore (obj, optc, opts);
792: break;
793:
794:
795: case FMAC_MIGRATE:
796: fm_migrate (obj, optc, opts);
797: break;
798:
799:
800: case FMAC_EDIT:
801: fm_edit (obj, optc, opts);
802: break;
803:
804:
805: case FMAC_SET:
806:
807: if (i < 2) {
808: printf ("fmadm: syntax error\n");
809: break;
810: }
811:
812: if (strcmp (args[0], "namespace") == 0) {
813: strcpy (fma_namespace, args[1]);
814:
815: if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
816: fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
817: return 1;
818: }
819:
820: if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
821: fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
822: return 1;
823: }
824:
825: if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
826: fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
827: return 1;
828: }
829:
830: if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
831: fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
832: return 1;
833: }
834:
835: if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
836: strcpy (fma_journal_path, "");
837: }
838:
839: if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
840: strcpy (fma_journal_cut_threshold, "1073741824");
841: }
842:
843: strcpy (gloplib, fma_pct_global_path);
844: stcnv_c2m (gloplib);
845:
846: strcpy (glopath, fma_global_path);
847: stcnv_c2m (glopath);
848:
849: snprintf (fma_prompt, STRLEN - 1, "fmadm [%s]> ", fma_namespace);
850:
851: }
852: else if (strcmp (args[0], "maintenance") == 0) {
853: if (strcmp (args[1], "on") == 0) {
854: shm_config->hdr->maintenance_mode = 1;
855: break;
856: }
857: else if (strcmp (args[1], "off") == 0) {
858: shm_config->hdr->maintenance_mode = 0;
859: break;
860: }
861: else {
862: printf ("fmadm: syntax error\n");
863: }
864:
865: printf ("fmadm: syntax error\n");
866:
867: }
868: else {
869: printf ("fmadm: syntax error\n");
870: break;
871: }
872:
873: break;
874:
875:
876: case FMAC_SHOW:
877: printf ("Namespace: %s\n", fma_namespace);
878: printf ("Routine Path: %s\n", fma_routine_path);
879: printf ("%%-Routine Path: %s\n", fma_pct_routine_path);
880: printf ("Global Path: %s\n", fma_global_path);
881: printf ("%%-Global Path: %s\n", fma_pct_global_path);
882: printf ("Journal File: %s\n", fma_journal_path);
1.5 snw 883: printf ("Journal Cut Threshold: %s bytes\n", fma_journal_cut_threshold);
1.1 snw 884: break;
885:
886: case FMAC_EXIT:
887: fmadm_exit (0);
888: break;
889:
890:
891: default:
892: printf ("fmadm: '%s' is not a valid fmadm command\n", cmdt);
893: break;
894:
895: }
896: }
897:
898: #endif
899:
900: }
901:
902: void fmadm_exit (int retval)
903: {
904: locktab_unlock_all ();
905: job_remove (pid);
906:
907: shm_exit ();
908:
909: exit (retval);
910: }
911:
912: int fmadm_usage (void)
913: {
914:
1.29 ! snw 915: fprintf (stdout, "\nusage: fmadm <action> <object> [-e=<environment] [-n=<namespace>] [-u=<user>] [-g=<group>] [-E=true|false] [OPTIONS]\n");
1.1 snw 916: fprintf (stdout, " fmadm configure\n");
917: fprintf (stdout, " fmadm reconfigure\n");
918:
919: fprintf (stdout, " <action> can be one of:\n");
920: fprintf (stdout, " list, examine, verify, compact, repair, create, remove,\n");
1.21 snw 921: fprintf (stdout, " import, export, backup, restore, migrate, edit, start,\n");
1.29 ! snw 922: fprintf (stdout, " stop, restart, status\n\n");
1.1 snw 923:
924: fprintf (stdout, " <object> can be one of:\n");
1.24 snw 925: fprintf (stdout, " lock, journal, namespace, global, routine, job,\n");
1.21 snw 926: fprintf (stdout, " environment\n\n");
1.1 snw 927:
928: fprintf (stdout, " Not all actions are valid for all objects. Please see the FreeM manual\n");
929: fprintf (stdout, " for details on fmadm usage and options.\n\n");
930:
931: return 1;
932:
933: } /* fmadm_usage() */
934:
935: int fm_list (short object, int optc, char **options)
936: {
937:
938: switch (object) {
939:
940: case OBJ_LOCK:
941: return fma_locks_list (optc, options);
942:
943: case OBJ_ROUTINE:
944: return fma_routines_list (optc, options);
945:
946: case OBJ_GLOBAL:
947: return fma_globals_list (optc, options);
948:
949: case OBJ_JOB:
950: return fma_jobs_list (optc, options);
951:
952: default:
953: fprintf (stderr, "fmadm: 'list' is an invalid action for '%s'\n", obj_str);
954: return 1;
955:
956: }
957:
958:
959: } /* fm_list() */
960:
961: int fm_examine (short object, int optc, char **options)
962: {
963:
964: switch (object) {
965:
966: case OBJ_ROUTINE:
967: return fma_routines_examine (optc, options);
968:
969: case OBJ_GLOBAL:
970: return fma_globals_examine (optc, options);
971:
972: case OBJ_JOB:
973: return fma_jobs_examine (optc, options);
974:
975: case OBJ_JOURNAL:
976: return fma_journals_examine (optc, options);
977:
978: default:
979: fprintf (stderr, "fmadm: 'examine' is an invalid action for '%s'\n", obj_str);
980: return 1;
981:
982: }
983:
984: } /* fm_examine() */
985:
986: int fm_verify (short object, int optc, char **options)
987: {
988:
989: switch (object) {
990:
991: case OBJ_GLOBAL:
992: return fma_globals_verify (optc, options);
993:
994: default:
995: fprintf (stderr, "fmadm: 'examine' is an invalid action for '%s'\n", obj_str);
996: return 1;
997:
998: }
999:
1000: } /* fm_verify() */
1001:
1002: int fm_compact (short object, int optc, char **options)
1003: {
1004:
1005: switch (object) {
1006:
1007: default:
1008: fprintf (stderr, "fmadm: 'compact' is an invalid action for '%s'\n", obj_str);
1009: return 1;
1010:
1011: }
1012:
1013: } /* fm_compact() */
1014:
1015: int fm_repair (short object, int optc, char **options)
1016: {
1017:
1018: switch (object) {
1019:
1020: default:
1021: fprintf (stderr, "fmadm: 'repair' is an invalid action for '%s'\n", obj_str);
1022: return 1;
1023:
1024: }
1025:
1026: } /* fm_repair() */
1027:
1028: int fm_create (short object, int optc, char **options)
1029: {
1030:
1031: switch (object) {
1032:
1033: default:
1034: fprintf (stderr, "fmadm: 'create' is an invalid action for '%s'\n", obj_str);
1035: return 1;
1036:
1037: }
1038: } /* fm_create() */
1039:
1040: int fm_remove (short object, int optc, char **options)
1041: {
1042:
1043: switch (object) {
1044:
1045: case OBJ_JOB:
1046: return fma_jobs_remove (optc, options);
1047:
1048: case OBJ_LOCK:
1049: return fma_locks_remove (optc, options);
1050:
1051: case OBJ_ROUTINE:
1052: return fma_routines_remove (optc, options);
1053:
1054: case OBJ_GLOBAL:
1055: return fma_globals_remove (optc, options);
1056:
1057: default:
1058: fprintf (stderr, "fmadm: 'remove' is an invalid action for '%s'\n", obj_str);
1059: return 1;
1060:
1061: }
1062:
1063: } /* fm_remove() */
1064:
1065: int fm_import (short object, int optc, char **options)
1066: {
1067:
1068: switch (object) {
1069:
1070: case OBJ_ROUTINE:
1071: return fma_routines_import (optc, options);
1072:
1073: default:
1074: fprintf (stderr, "fmadm: 'import' is an invalid action for '%s'\n", obj_str);
1075: return 1;
1076:
1077: }
1078:
1079: } /* fm_import() */
1080:
1081: int fm_export (short object, int optc, char **options)
1082: {
1083:
1084: switch (object) {
1085:
1086: case OBJ_ROUTINE:
1087: return fma_routines_export (optc, options);
1088:
1089: default:
1090: fprintf (stderr, "fmadm: 'export' is an invalid action for '%s'\n", obj_str);
1091: return 1;
1092:
1093: }
1094:
1095: } /* fm_export() */
1096:
1097: int fm_backup (short object, int optc, char **options)
1098: {
1099:
1100: switch (object) {
1101:
1102: case OBJ_ROUTINE:
1103: return fma_routines_backup (optc, options);
1104:
1105: default:
1106: fprintf (stderr, "fmadm: 'backup' is an invalid action for '%s'\n", obj_str);
1107: return 1;
1108:
1109: }
1110:
1111: } /* fm_backup() */
1112:
1113: int fm_restore (short object, int optc, char **options)
1114: {
1115:
1116: switch (object) {
1117:
1118: case OBJ_JOURNAL:
1119: return fma_journals_restore (optc, options);
1120:
1121: default:
1122: fprintf (stderr, "fmadm: 'restore' is an invalid action for '%s'\n", obj_str);
1123: return 1;
1124:
1125: }
1126:
1127: } /* fm_restore() */
1128:
1129: int fm_migrate (short object, int optc, char **options)
1130: {
1131:
1132: switch (object) {
1133:
1134: default:
1135: fprintf (stderr, "fmadm: 'migrate' is an invalid action for '%s'\n", obj_str);
1136: return 1;
1137:
1138: }
1139:
1140: } /* fm_migrate() */
1141:
1142: int fm_edit (short object, int optc, char **options)
1143: {
1144:
1145: switch (object) {
1146:
1147: case OBJ_ROUTINE:
1148: return fma_routines_edit (optc, options);
1149:
1.18 snw 1150: case OBJ_GLOBAL:
1.1 snw 1151: return fma_globals_edit (optc, options);
1.18 snw 1152:
1.1 snw 1153: default:
1154: fprintf (stderr, "fmadm: 'edit' is an invalid action for '%s'\n", obj_str);
1155: return 1;
1156:
1157: }
1158:
1159: } /* fm_edit() */
1160:
1.22 snw 1161: long fm_get_pid (char *env)
1162: {
1163: char pid_file[4096];
1164: char tmp_pid[255];
1165: long res;
1166:
1167: FILE *fp;
1168:
1169: snprintf (pid_file, 4095, "%s/freem/run/%s.pid", LOCALSTATEDIR, env);
1170:
1171: if ((fp = fopen (pid_file, "r")) != NULL) {
1172: if (fgets (tmp_pid, 255, fp)) {
1173: fclose (fp);
1174: return atol (tmp_pid);
1175: }
1176: else {
1177: fclose (fp);
1178: return -1;
1179: }
1180: }
1181: else {
1182: return -1;
1183: }
1184: }
1185:
1.26 snw 1186: int fm_validate_environment (char *env)
1187: {
1188: FILE *fp;
1189: char line[255];
1190: char chkline[255];
1191:
1192: snprintf (chkline, 254, "[%s]\n", env);
1193:
1194: if ((fp = fopen (env_config_file, "r")) == NULL) {
1195: fprintf (stderr, "fmadm: could not open %s [%s]\n", env_config_file, strerror (errno));
1196: return FALSE;
1197: }
1198:
1199: while (fgets (line, 254, fp)) {
1200: if (strncmp (line, chkline, 254) == 0) {
1201: fclose (fp);
1202: return TRUE;
1203: }
1204: }
1205:
1206: fclose (fp);
1207: return FALSE;
1208: }
1209:
1210: int fm_start_environment (char *env, char *e_user, char *e_grp)
1211: {
1212: char basecmd[255];
1213: char cmd[4096];
1.27 snw 1214:
1215: if (fm_environment_running (env) == TRUE) {
1216: return TRUE;
1217: }
1.26 snw 1218:
1219: #if !defined(__OS2__)
1220: snprintf (basecmd, 254, "%s/bin/freem", PREFIX);
1221: #else
1222: snprintf (basecmd, 254, "%s/bin/freemd.exe", PREFIX);
1223: #endif
1224:
1225: #if !defined(__OS2__)
1.27 snw 1226: snprintf (cmd, 4095, "%s -d -e %s -u %s -g %s", basecmd, env, e_user, e_grp);
1.26 snw 1227: #else
1.27 snw 1228: sprintf (cmd, 4095, "%s -d -k -e %s -u %s -g %s", basecmd, env, e_user, e_grp);
1.26 snw 1229: #endif
1.27 snw 1230:
1231: system (cmd);
1232:
1233: sleep (1);
1.26 snw 1234:
1.27 snw 1235: return (fm_environment_running (env));
1.26 snw 1236: }
1237:
1238: int fm_stop_environment (char *env)
1239: {
1240: long epid;
1241:
1.27 snw 1242: epid = fm_get_pid (env);
1.26 snw 1243: if (epid > -1) {
1244: kill (epid, SIGINT);
1.27 snw 1245: sleep (5);
1246:
1247: if (fm_environment_running (env) == FALSE) {
1248: return TRUE;
1249: }
1250: else {
1251: kill (epid, SIGTERM);
1252: sleep (5);
1253: if (fm_environment_running (env) == FALSE) {
1254: return TRUE;
1255: }
1256: else {
1257: kill (epid, SIGKILL);
1258: sleep (5);
1259: if (fm_environment_running (env) == FALSE) {
1260: return TRUE;
1261: }
1262: else {
1263: return FALSE;
1264: }
1265: }
1266: }
1.26 snw 1267: }
1268: else {
1.27 snw 1269: return FALSE;
1.26 snw 1270: }
1271: }
1272:
1.27 snw 1273: int fm_environment_running (char *env)
1274: {
1275: long epid;
1276: int result;
1277:
1278: epid = fm_get_pid (env);
1279:
1280: if (epid == -1) {
1281: return FALSE;
1282: }
1283: else {
1284: result = kill (epid, 0);
1285:
1286: return ((result == 0) ? TRUE : FALSE);
1287: }
1288: }
1289:
1.21 snw 1290: int fm_daemonctl (short action, short object, int optc, char **options)
1291: {
1292: FILE *ef;
1293: char *envlist;
1294: char env[255];
1295: char line[255];
1296: char tmps[255];
1297: char *cur_env;
1.23 snw 1298: char verb[40];
1.21 snw 1299: char e_user[255];
1300: char e_grp[255];
1301: char e_ena[10];
1302: char *savptr;
1303: int result;
1.22 snw 1304: long epid;
1.26 snw 1305:
1.21 snw 1306:
1307: switch (action) {
1308: case ACT_START:
1309: sprintf (verb, "starting");
1310: break;
1311: case ACT_STOP:
1312: sprintf (verb, "stopping");
1313: break;
1314: case ACT_RESTART:
1315: sprintf (verb, "restarting");
1316: break;
1.23 snw 1317: case ACT_STATUS:
1318: sprintf (verb, "checking status of");
1319: break;
1.21 snw 1320: }
1321:
1322: if (optc) {
1323: /* environment list specified as command-line argument */
1.23 snw 1324: envlist = (char *) malloc (sizeof (char) * BIGSTR);
1325: NULLPTRCHK(envlist,"fm_daemonctl");
1326:
1.26 snw 1327: strcpy (envlist, options[1]);
1.21 snw 1328: }
1329: else {
1330: /* no environment specified; do 'action' for all environments */
1331: envlist = (char *) malloc (sizeof (char) * BIGSTR);
1332: NULLPTRCHK(envlist,"fm_daemonctl");
1333:
1334: ef = fopen (env_config_file, "r");
1335:
1336: while (fgets (line, 254, ef)) {
1337: if (line[0] == '[') {
1338: strncpy (env, &(line[1]), 255);
1339: env[strlen (env) - 2] = '\0';
1340: snprintf (tmps, 255, "%s,", env);
1341: strncat (envlist, tmps, BIGSTR - 1);
1342: }
1343: }
1344: envlist[strlen (envlist) - 1] = '\0';
1345:
1346: fclose (ef);
1347: }
1348:
1349: savptr = envlist;
1350: cur_env = strtok_r (envlist, ",", &savptr);
1351: do {
1.26 snw 1352:
1353: if (fm_validate_environment (cur_env) == FALSE) {
1354: fprintf (stderr, "fmadm: %s is not a valid environment\n", cur_env);
1355: continue;
1356: }
1357:
1.21 snw 1358: result = read_profile_string (env_config_file, cur_env, "enabled", e_ena);
1359: if (result == FALSE || strcmp (e_ena, "true") == 0) {
1360:
1361: result = read_profile_string (env_config_file, cur_env, "user", e_user);
1362: if (result == FALSE) {
1363: strcpy (e_user, "freem");
1364: }
1365: result = read_profile_string (env_config_file, cur_env, "group", e_grp);
1366: if (result == FALSE) {
1367: strcpy (e_grp, "freem");
1368: }
1.22 snw 1369:
1.27 snw 1370: switch (action) {
1371: case ACT_START:
1372: case ACT_STOP:
1373: case ACT_RESTART:
1374: fprintf (stderr, "fmadm: %s environment %s... ", verb, cur_env);
1375: break;
1376: case ACT_STATUS:
1377: fprintf (stderr, "fmadm: %s environment %s\n", verb, cur_env);
1378: break;
1379: }
1.21 snw 1380:
1381: switch (action) {
1.26 snw 1382:
1.21 snw 1383: case ACT_START:
1.26 snw 1384: result = fm_start_environment (cur_env, e_user, e_grp);
1.27 snw 1385: if (result == TRUE) {
1386: fprintf (stderr, "[OK]\n");
1387: }
1388: else {
1389: fprintf (stderr, "[FAIL]\n");
1390: }
1.21 snw 1391: break;
1.26 snw 1392:
1.21 snw 1393: case ACT_STOP:
1.26 snw 1394: result = fm_stop_environment (cur_env);
1.27 snw 1395: if (result == TRUE) {
1396: fprintf (stderr, "[OK]\n");
1397: }
1398: else {
1399: fprintf (stderr, "[FAIL]\n");
1400: }
1.22 snw 1401: break;
1.26 snw 1402:
1.21 snw 1403: case ACT_RESTART:
1.27 snw 1404: if (fm_stop_environment (cur_env) == TRUE) {
1405: result = fm_start_environment (cur_env, e_user, e_grp);
1406: if (result == TRUE) {
1407: fprintf (stderr, "[OK]\n");
1408: }
1409: else {
1410: fprintf (stderr, "[FAIL]\n");
1411: }
1412: }
1413: else {
1414: fprintf (stderr, "[FAIL]\n");
1415: }
1.22 snw 1416:
1.21 snw 1417: break;
1.26 snw 1418:
1.23 snw 1419: case ACT_STATUS:
1420: epid = fm_get_pid (cur_env);
1421: if (epid > -1) {
1422: fprintf (stderr, " - %s environment daemon running as pid %d\n", cur_env, epid);
1423: }
1424: else {
1425: fprintf (stderr, " - %s environment daemon does not appear to be running\n", cur_env);
1426: }
1.22 snw 1427: }
1.21 snw 1428: }
1429: else {
1430: printf ("fmadm: %s environment is disabled; skipping\n", cur_env);
1431: }
1432: } while ((cur_env = strtok_r (NULL, ",", &savptr)) != NULL);
1433:
1434: free (envlist);
1435: exit (0);
1436:
1437: } /* fm_daemonctl() */
1438:
1.1 snw 1439: void fm_checkperms(void)
1440: {
1441:
1442: } /* fm_checkperms() */
1443:
1444:
1445: void fm_reconfigure(void)
1446: {
1447: char config_backup[4096];
1448: char vers[4096];
1449:
1450: int retval;
1451:
1452: if (geteuid () != 0) {
1453: fprintf (stderr, "fmadm: not superuser\n");
1454: exit (1);
1455: }
1456:
1457: snprintf (config_backup, 4095, "%s.orig", config_file);
1458:
1459: fprintf (stderr, "fmadm: reconfiguring FreeM with system defaults for %s...\n", FREEM_VERSION_CSTR);
1460: fprintf (stderr, "fmadm: backing up %s to %s...\t", config_file, config_backup);
1461:
1.29 ! snw 1462: #if !defined(__OS2__)
! 1463: retval = cp (config_backup, config_file);
! 1464: #else
! 1465: retval = DosCopy (config_file, config_backup);
! 1466: #endif
1.1 snw 1467:
1468: if (retval == 0) {
1.18 snw 1469: fprintf (stderr, "[OK]\n");
1.1 snw 1470:
1471: fm_configure ();
1472:
1473: fprintf (stderr, "\n\nYou may wish to edit %s if site-specific changes were made to the original FreeM configuration.\n", config_file);
1474: exit (0);
1475: }
1476: else {
1477: fprintf (stderr, "[FAIL (%s)]\n", strerror (errno));
1478: exit (1);
1479: }
1480:
1481: } /* fm_reconfigure() */
1482:
1.29 ! snw 1483: void update_conf (char *file, char *section, char *key, char *new_value)
! 1484: {
! 1485: char old_value[255];
! 1486: char tbuf[255];
! 1487:
! 1488: snprintf (tbuf, 254, "%s.%s", section, key);
! 1489:
! 1490: read_profile_string (file, section, key, old_value);
! 1491: if (strcmp (old_value, new_value) != 0) {
! 1492: modify_profile_string (file, section, key, new_value);
! 1493: fprintf (stderr, "\t%-40s%-20s -> %s\n", tbuf, old_value, new_value);
! 1494: }
! 1495: else {
! 1496: fprintf (stderr, "\t%-40s%-20s\n", tbuf, "no change");
! 1497: }
! 1498: }
1.1 snw 1499:
1500: void fm_configure (void)
1501: {
1.21 snw 1502: char rundir[4096];
1.19 snw 1503: char varbase[4096];
1.1 snw 1504: char sysrtn[4096];
1505: char sysgbl[4096];
1506: char usrrtn[4096];
1507: char usrgbl[4096];
1508:
1.23 snw 1509: char jnldir[4096];
1.1 snw 1510: char jnlfile[4096];
1511: char jnlmode[4];
1512: char jnlhostid[4096];
1513: char jnlcut[4096];
1514: char hostid[4096];
1515:
1516: char confbase[4096];
1517: char envbase[4096];
1518:
1519: char nsbase[4096];
1520:
1521: char buf[4096];
1522: FILE *fp;
1523:
1.29 ! snw 1524: int reconfigure = FALSE;
! 1525:
1.1 snw 1526: struct stat etcstat;
1527: int stat_result;
1.19 snw 1528:
1529: DIR *dir;
1530: struct dirent *ent;
1531: char src_dir[4096];
1532: char dest_dir[4096];
1533:
1.20 snw 1534: char *username = env_user;
1535: char *groupname = env_group;
1.28 snw 1536:
1.20 snw 1537: #if !defined(__OS2__)
1.24 snw 1538: if (geteuid () != 0) {
1539: fprintf (stderr, "fmadm: not superuser\n");
1540: exit (1);
1541: }
1542:
1.19 snw 1543: struct group *d_grp;
1544: struct passwd *d_user;
1545: gid_t d_gid;
1.20 snw 1546: uid_t d_uid;
1.19 snw 1547:
1.20 snw 1548: if ((d_grp = getgrnam (groupname)) == NULL) {
1549: fprintf (stderr, "fmadm: '%s' group must exist before configuring\n", groupname);
1550: exit (1);
1551: }
1552: d_gid = d_grp->gr_gid;
1553:
1554: if ((d_user = getpwnam (username)) == NULL) {
1555: fprintf (stderr, "fmadm: '%s' user must exist before configuring\n", username);
1556: exit (1);
1557: }
1558: d_uid = d_user->pw_uid;
1559: #endif
1.23 snw 1560:
1.19 snw 1561: snprintf (varbase, 4095, "%s/freem", LOCALSTATEDIR);
1.21 snw 1562: snprintf (rundir, 4095, "%s/freem/run", LOCALSTATEDIR);
1.1 snw 1563: snprintf (sysrtn, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
1564: snprintf (sysgbl, 4095, "%s/freem/%s/SYSTEM/globals", LOCALSTATEDIR, fma_environment);
1565: snprintf (usrrtn, 4095, "%s/freem/%s/USER/routines", LOCALSTATEDIR, fma_environment);
1566: snprintf (usrgbl, 4095, "%s/freem/%s/USER/globals", LOCALSTATEDIR, fma_environment);
1.23 snw 1567: snprintf (jnldir, 4095, "%s/freem/%s/journals", LOCALSTATEDIR, fma_environment);
1568: snprintf (jnlfile, 4095, "%s/freem_journal_%s.dat", jnldir, fma_environment);
1.1 snw 1569: snprintf (jnlmode, 3, "on");
1570: snprintf (jnlhostid, 4095, "DEFAULT");
1571: snprintf (jnlcut, 4095, "4294967000");
1572:
1573: if (geteuid () != 0) {
1574: fprintf (stderr, "fmadm: not superuser\n");
1575: exit (1);
1576: }
1577:
1578: if (file_exists (config_file)) {
1.29 ! snw 1579: reconfigure = TRUE;
1.1 snw 1580: }
1.29 ! snw 1581:
1.1 snw 1582: gethostname (hostid, 4095);
1583: uuid_v4 (buf);
1584:
1585: snprintf (jnlhostid, 4095, "%s:%s", hostid, buf);
1586: snprintf (confbase, 4095, "%s/freem", SYSCONFDIR);
1587: snprintf (envbase, 4095, "%s/freem/%s", SYSCONFDIR, fma_environment);
1588: snprintf (nsbase, 4095, "%s/freem/%s", LOCALSTATEDIR, fma_environment);
1589:
1.9 snw 1590: #if defined(__OS2__)
1591: {
1592: char srcfile[PATHLEN];
1.11 snw 1593: char dstfile[PATHLEN];
1594:
1.9 snw 1595: snprintf (srcfile, PATHLEN, "%s/bin/freem.exe", PREFIX);
1596: snprintf (dstfile, PATHLEN, "%s/bin/freemd.exe", PREFIX);
1.11 snw 1597:
1598: unlink (dstfile);
1.9 snw 1599:
1.10 snw 1600: fprintf (stderr, "fmadm: running on OS/2; will copy %s to %s\n", srcfile, dstfile);
1.12 snw 1601:
1.16 snw 1602: if (DosCopy (srcfile, dstfile, 1) != 0) {
1.9 snw 1603: fprintf (stderr, "fmadm: fatal error copying %s to %s\n", srcfile, dstfile);
1604: exit (1);
1605: }
1.13 snw 1606:
1607: chmod (dstfile, 0755);
1.9 snw 1608: }
1609: #endif
1.1 snw 1610:
1.29 ! snw 1611: if (reconfigure == FALSE) {
! 1612: printf ("\nFreeM Initial Environment Configuration\n");
! 1613: printf ("---------------------------------------\n\n");
! 1614:
! 1615: printf ("This utility will create the initial configuration files for ");
! 1616: printf ("FreeM environment '%s' (owned by %s:%s) in '%s'.\n\n", fma_environment, username, groupname, config_file);
! 1617: }
! 1618: else {
! 1619: printf ("\nFreeM Environment Upgrade/Reconfiguration\n");
! 1620: printf ("-----------------------------------------\n\n");
! 1621:
! 1622: printf ("This utility will update the configuration files for ");
! 1623: printf ("FreeM environment '%s' (owned by %s:%s) in '%s'.\n\n", fma_environment, username, groupname, config_file);
! 1624: }
1.9 snw 1625:
1.1 snw 1626: /* check for existence of needed directories */
1627: if (stat (SYSCONFDIR, &etcstat) == -1) {
1.23 snw 1628: fprintf (stderr, "fmadm: creating %s [SYSCONFDIR]\n", SYSCONFDIR);
1.19 snw 1629: mkdir (SYSCONFDIR, 0775);
1.20 snw 1630: set_permissions (SYSCONFDIR, username, groupname, 0775);
1.1 snw 1631: }
1632:
1633: if (stat (confbase, &etcstat) == -1) {
1.23 snw 1634: fprintf (stderr, "fmadm: creating %s [confbase]\n", confbase);
1.19 snw 1635: mkdir (confbase, 0775);
1.20 snw 1636: set_permissions (confbase, username, groupname, 0775);
1.1 snw 1637: }
1638:
1.19 snw 1639: if (stat (varbase, &etcstat) == -1) {
1.23 snw 1640: fprintf (stderr, "fmadm: creating %s [varbase]\n", varbase);
1.19 snw 1641: mkdir (varbase, 0775);
1.20 snw 1642: set_permissions (varbase, username, groupname, 0775);
1.19 snw 1643: }
1.21 snw 1644:
1.23 snw 1645: if (stat (envbase, &etcstat) == -1) {
1646: fprintf (stderr, "fmadm: creating %s [envbase]\n", envbase);
1647: mkdir (envbase, 0775);
1648: set_permissions (envbase, username, groupname, 0775);
1649: }
1650:
1.21 snw 1651: if (stat (rundir, &etcstat) == -1) {
1.23 snw 1652: fprintf (stderr, "fmadm: creating %s [rundir]\n", rundir);
1.21 snw 1653: mkdir (rundir, 0777);
1654: chmod (rundir, 0777);
1655: }
1656:
1.1 snw 1657: if (stat (nsbase, &etcstat) == -1) {
1.23 snw 1658: fprintf (stderr, "fmadm: creating %s [nsbase]\n", nsbase);
1.19 snw 1659: mkdir (nsbase, 0775);
1.20 snw 1660: set_permissions (nsbase, username, groupname, 0775);
1.1 snw 1661: }
1662:
1.23 snw 1663: if (stat (jnldir, &etcstat) == -1) {
1664: fprintf (stderr, "fmadm: creating %s [jnldir]\n", jnldir);
1665: mkdir (jnldir, 0775);
1666: set_permissions (jnldir, username, groupname, 0775);
1667: }
1668:
1669:
1.19 snw 1670: snprintf (src_dir, 4095, "%s/freem/mlib", DATADIR);
1671: snprintf (dest_dir, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
1.29 ! snw 1672:
! 1673: if (reconfigure == FALSE) {
! 1674: fprintf (stderr, "fmadm: populating new environment '%s'\n", fma_environment);
! 1675: }
! 1676: else {
! 1677: fprintf (stderr, "fmadm: upgrading environment '%s'\n", fma_environment);
! 1678: }
1.19 snw 1679:
1680: snprintf (buf, 4095, "%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
1681: mkdir (buf, 0775);
1.20 snw 1682: set_permissions (buf, username, groupname, 0775);
1.19 snw 1683:
1684: snprintf (buf, 4095, "%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
1685: mkdir (buf, 0775);
1.20 snw 1686: set_permissions (buf, username, groupname, 0775);
1.19 snw 1687:
1688: snprintf (buf, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
1689: mkdir (buf, 0775);
1.20 snw 1690: set_permissions (buf, username, groupname, 0775);
1.19 snw 1691:
1692: snprintf (buf, 4095, "%s/freem/%s/USER/globals", LOCALSTATEDIR, fma_environment);
1693: mkdir (buf, 0775);
1.20 snw 1694: set_permissions (buf, username, groupname, 0775);
1.19 snw 1695:
1696: snprintf (buf, 4095, "%s/freem/%s/SYSTEM/globals", LOCALSTATEDIR, fma_environment);
1697: mkdir (buf, 0775);
1.20 snw 1698: set_permissions (buf, username, groupname, 0775);
1.19 snw 1699:
1700: snprintf (buf, 4095, "%s/freem/%s/USER/routines", LOCALSTATEDIR, fma_environment);
1701: mkdir (buf, 0775);
1.20 snw 1702: set_permissions (buf, username, groupname, 0775);
1.19 snw 1703:
1.25 snw 1704: fprintf (stderr, "fmadm: copying vendor routines from '%s' to '%s'...\n", src_dir, dest_dir);
1.1 snw 1705:
1.19 snw 1706: if ((dir = opendir (src_dir)) == NULL) {
1707: fprintf (stderr, "\nfmadm: could not open source directory %s\n", src_dir);
1708: exit (1);
1709: }
1710:
1711: while ((ent = readdir (dir)) != NULL) {
1712: char infile[4096];
1713: char outfile[4096];
1.1 snw 1714:
1.25 snw 1715: if ((strcmp (ent->d_name, ".") != 0) && (strcmp (ent->d_name, "..") != 0)) {
1.19 snw 1716:
1717: snprintf (infile, 4095, "%s/%s", src_dir, ent->d_name);
1718: snprintf (outfile, 4095, "%s/%s", dest_dir, ent->d_name);
1.1 snw 1719:
1.25 snw 1720: if (stat (outfile, &etcstat) == 0) {
1721: unlink (outfile);
1722: fprintf (stderr, "\tupgrade -> %s\n", ent->d_name);
1723: }
1724: else {
1725: fprintf (stderr, "\tnew -> %s\n", ent->d_name);
1726: }
1727:
1.19 snw 1728: #if !defined(__OS2__)
1729: if (cp (outfile, infile) != 0) {
1730: fprintf (stderr, "fmadm: failure copying %s to %s\n", infile, outfile);
1731: }
1.20 snw 1732: set_permissions (outfile, username, groupname, 0755);
1.19 snw 1733: #else
1734: if (DosCopy (infile, outfile, 1) != 0) {
1735: fprintf (stderr, "fmadm: failure copying %s to %s\n", infile, outfile);
1.1 snw 1736: }
1.19 snw 1737: #endif
1.1 snw 1738:
1739: }
1740:
1741: }
1.20 snw 1742:
1.28 snw 1743: if (fm_validate_environment (fma_environment) == FALSE) {
1744: fp = fopen (env_config_file, "a+");
1745:
1746: fprintf (stderr, "Creating %s... ", env_config_file);
1747:
1748: snprintf (buf, 4095, "[%s]", fma_environment);
1749: fm_write (fp, buf);
1750:
1751: snprintf (buf, 4095, "user=%s", env_user);
1752: fm_write (fp, buf);
1753:
1754: snprintf (buf, 4095, "group=%s", env_group);
1755: fm_write (fp, buf);
1756:
1.29 ! snw 1757: snprintf (buf, 4095, "enabled=%s", env_enabled);
1.28 snw 1758: fm_write (fp, buf);
1759:
1760: snprintf (buf, 4095, "env_path=%s/freem/%s", LOCALSTATEDIR, fma_environment);
1761: fm_write (fp, buf);
1762:
1763: fclose (fp);
1764: fprintf (stderr, "[OK]\n");
1765: }
1766: else {
1767: char modtmp[255];
1768:
1.29 ! snw 1769: fprintf (stderr, "\nUpdating %s: \n", env_config_file);
1.20 snw 1770:
1.29 ! snw 1771: update_conf (env_config_file, fma_environment, "user", env_user);
! 1772: update_conf (env_config_file, fma_environment, "group", env_group);
! 1773: update_conf (env_config_file, fma_environment, "enabled", env_enabled);
1.28 snw 1774: }
1.29 ! snw 1775:
! 1776: if (reconfigure == FALSE) {
! 1777: fp = fopen (config_file, "a+");
! 1778:
! 1779: fprintf (stderr, "Creating %s... ", config_file);
! 1780:
! 1781: snprintf (buf, 4095, "[SYSTEM]");
! 1782: fm_write (fp, buf);
! 1783:
! 1784: snprintf (buf, 4095, "root=%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
! 1785: fm_write (fp, buf);
! 1786:
! 1787: snprintf (buf, 4095, "routines_path=%s", sysrtn);
! 1788: fm_write (fp, buf);
! 1789:
! 1790: snprintf (buf, 4095, "globals_path=%s", sysgbl);
! 1791: fm_write (fp, buf);
! 1792:
! 1793: snprintf (buf, 4095, "journal_file=%s", jnlfile);
! 1794: fm_write (fp, buf);
! 1795:
! 1796: snprintf (buf, 4095, "journal_mode=%s", jnlmode);
! 1797: fm_write (fp, buf);
! 1798:
! 1799: snprintf (buf, 4095, "journal_host_id=%s", jnlhostid);
! 1800: fm_write (fp, buf);
! 1801:
! 1802: snprintf (buf, 4095, "journal_cut_threshold=%s", jnlcut);
! 1803: fm_write (fp, buf);
! 1804:
! 1805: snprintf (buf, 4095, "zdate_format=%%x");
! 1806: fm_write (fp, buf);
! 1807:
! 1808: snprintf (buf, 4095, "ztime_format=%%X");
! 1809: fm_write (fp, buf);
! 1810:
! 1811: snprintf (buf, 4095, "\n[USER]");
! 1812: fm_write (fp, buf);
! 1813:
! 1814: snprintf (buf, 4095, "root=%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
! 1815: fm_write (fp, buf);
! 1816:
! 1817: snprintf (buf, 4095, "routines_path=%s", usrrtn);
! 1818: fm_write (fp, buf);
! 1819:
! 1820: snprintf (buf, 4095, "globals_path=%s", usrgbl);
! 1821: fm_write (fp, buf);
! 1822:
! 1823: fclose (fp);
! 1824: set_permissions (config_file, username, groupname, 0755);
! 1825: fprintf (stderr, "[OK]\n");
1.1 snw 1826:
1.29 ! snw 1827: printf ("FreeM initial configuration is complete.\n\n");
! 1828: }
! 1829: else {
! 1830: char tmpsd[255];
! 1831: read_profile_string (config_file, "SYSTEM", "journal_host_id", tmpsd);
! 1832:
! 1833: /* existing configuration */
! 1834: fprintf (stderr, "\nUpdating environment configuration for %s:\n", fma_environment);
1.1 snw 1835:
1.29 ! snw 1836: snprintf (buf, 4095, "%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
! 1837: update_conf (config_file, "SYSTEM", "root", buf);
! 1838: update_conf (config_file, "SYSTEM", "routines_path", sysrtn);
! 1839: update_conf (config_file, "SYSTEM", "globals_path", sysgbl);
! 1840: update_conf (config_file, "SYSTEM", "journal_file", jnlfile);
! 1841: update_conf (config_file, "SYSTEM", "journal_mode", jnlmode);
! 1842: update_conf (config_file, "SYSTEM", "journal_host_id", tmpsd);
! 1843: update_conf (config_file, "SYSTEM", "journal_cut_threshold", jnlcut);
! 1844:
! 1845: snprintf (buf, 4095, "%%x");
! 1846: update_conf (config_file, "SYSTEM", "zdate_format", buf);
! 1847:
! 1848: snprintf (buf, 4095, "%%X");
! 1849: update_conf (config_file, "SYSTEM", "ztime_format", buf);
! 1850:
! 1851: /* USER */
! 1852: snprintf (buf, 4095, "%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
! 1853: update_conf (config_file, "USER", "root", buf);
! 1854: update_conf (config_file, "USER", "routines_path", usrrtn);
! 1855: update_conf (config_file, "USER", "globals_path", usrgbl);
1.1 snw 1856:
1.29 ! snw 1857: }
1.1 snw 1858:
1.20 snw 1859:
1.29 ! snw 1860: printf ("\n\nUSER globals: %s\n", usrgbl);
! 1861: printf ("USER routines: %s\n", usrrtn);
! 1862: printf ("SYSTEM globals: %s\n", sysgbl);
! 1863: printf ("SYSTEM routines: %s\n", sysrtn);
! 1864: printf ("After-image journal: %s [%s]\n", jnlfile, jnlmode);
! 1865: printf ("Journal cut threshold: %s bytes\n", jnlcut);
! 1866: printf ("Distributed journaling host ID: %s\n", jnlhostid);
1.1 snw 1867:
1.29 ! snw 1868: if (reconfigure == TRUE) {
! 1869: fprintf (stderr, "\nIf you previously defined environments other than '%s', you should run\n'fmadm reconfigure -e=<environment-name>' on each of them to ensure they have\nthe latest vendor routines and correct, updated settings.\n\n", fma_environment);
! 1870: }
1.1 snw 1871:
1872: } /* fm_configure */
1873:
1.20 snw 1874: void set_permissions(char *path, char *user, char *grp, int mode)
1875: {
1876:
1877: #if !defined(__OS2__)
1878: struct group *d_grp;
1879: struct passwd *d_user;
1880: gid_t d_gid;
1881: uid_t d_uid;
1882: #endif
1883:
1884:
1885: #if !defined(__OS2__)
1886: if ((d_grp = getgrnam (grp)) == NULL) {
1887: fprintf (stderr, "fmadm: '%s' group must exist before configuring\n", grp);
1888: exit (1);
1889: }
1890: d_gid = d_grp->gr_gid;
1891:
1892: if ((d_user = getpwnam (user)) == NULL) {
1893: fprintf (stderr, "fmadm: '%s' user must exist before configuring\n", user);
1894: exit (1);
1895: }
1896: d_uid = d_user->pw_uid;
1897:
1898: if (chown (path, d_uid, d_gid) != 0) {
1899: fprintf (stderr, "fmadm: error setting ownership on %s\n", path);
1900: exit (1);
1901: }
1902: #endif
1903:
1904: if (chmod (path, mode) != 0) {
1905: fprintf (stderr, "fmadm: error setting permissions on %s to %d\n", path, mode);
1906: exit (1);
1907: }
1908:
1909: }
1910:
1.1 snw 1911: void fm_write (FILE *file, char *buf)
1912: {
1913: fprintf (file, "%s\n", buf);
1914: }
1915:
1916: void fm_sig_attach (int sig, void *handler)
1917: {
1918: struct sigaction act;
1919:
1920: act.sa_handler = handler;
1921: sigaction (sig, &act, NULL);
1922:
1923: }
1924:
1925: void fm_sig_init (void)
1926: {
1927: sig_attach (SIGINT, &fm_on_sigint);
1928: sig_attach (SIGTERM, &fm_on_sigterm);
1929: }
1930:
1931: void fm_on_sigint (void)
1932: {
1933: fprintf (stderr, "\nfmadm: caught SIGINT\n");
1934: fmadm_exit (0);
1935: }
1936:
1937: void fm_on_sigterm (void)
1938: {
1939: fprintf (stderr, "\nfmadm: caught SIGTERM\n");
1940: fmadm_exit (0);
1941: }
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