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