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