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