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