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