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