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