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