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