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