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