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