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