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