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