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