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