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