Annotation of freem/src/fma_routines.c, revision 1.3
1.1 snw 1: /*
1.3 ! snw 2: * $Id$
1.1 snw 3: * fmadm - routines
4: *
5: *
1.2 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.3 ! 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.3 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31:
32: #include <stdio.h>
33: #include <stdlib.h>
34: #include <string.h>
35: #include <dirent.h>
36: #include <stdlib.h>
37: #include <time.h>
38: #include <unistd.h>
39: #include <sys/types.h>
40: #include <sys/stat.h>
41: #include <ctype.h>
42: #include <errno.h>
43:
44: #include "fmadm.h"
45: #include "iniconf.h"
46:
47: int fma_do_export (FILE *out, char *rtn_name);
48: char *fma_trim_string(char *str);
49:
50: int fma_routines_list (int optc, char **opts)
51: {
52:
53: DIR *dir;
54: struct dirent *ent;
55:
56: char filename[STRLEN];
57: char *rtnname;
58: char *rtnext;
59:
60: int ct = 0;
61:
62: printf ("\nFreeM Routine Listing\n");
63: printf ("---------------------\n\n");
64:
65: printf ("Namespace: %s\n", fma_namespace);
66: printf ("Routine Path: %s\n\n", fma_routine_path);
67:
68: if ((dir = opendir (fma_routine_path)) == NULL) {
69: fprintf (stderr, "fmadm: could not open routine directory %s\n", fma_routine_path);
70: return 1;
71: }
72:
73: while ((ent = readdir (dir)) != NULL) {
74:
75: strncpy (filename, ent->d_name, STRLEN - 1);
76:
77: rtnname = strtok (filename, ".");
78: rtnext = strtok (NULL, ".");
79:
80: if (rtnext != NULL && strncmp (rtnext, "m", STRLEN - 1) == 0) {
81: printf (" %s\n", rtnname);
82: ct++;
83: }
84:
85: }
86:
87: printf ("\n\n - %d routines found\n\n", ct);
88: closedir (dir);
89:
90: return 0;
91:
92: }
93:
94: int fma_routines_edit (int optc, char **opts)
95: {
96: FILE *fp;
97: char rpath[STRLEN];
98: char ecmd[STRLEN];
99: char *editor;
100:
101: if (optc < fma_min_args) {
102: fprintf (stderr, "fmadm: must supply routine name\n");
103: return 1;
104: }
105:
106:
107: if ((editor = getenv("EDITOR")) == NULL) {
108:
109: if ((editor = (char *) malloc (3 * sizeof (char))) == NULL) {
110: fprintf (stderr, "fmadm: could not acquire memory\n");
111: return 1;
112: }
113:
114: strncpy (editor, "vi", 3);
115:
116: }
117:
118: snprintf (rpath, STRLEN - 1, "%s/%s.m", fma_routine_path, opts[fma_base_opt]);
119:
120: if (file_exists (rpath) == FALSE) {
121: if ((fp = fopen (rpath, "w")) == NULL) {
122: fprintf (stderr, "fmadm: error %d creating routine %s (%s)\n", errno, opts[1], strerror (errno));
123:
124: return 1;
125: }
126:
127: fprintf (fp, "%s ; Created by FreeM Administrator\n QUIT\n", opts[1]);
128: fclose (fp);
129:
130: }
131:
132: snprintf (ecmd, STRLEN - 1, "%s %s", editor, rpath);
133: system (ecmd);
134:
135: return 0;
136:
137: }
138:
139: int fma_routines_examine (int optc, char **opts)
140: {
141:
142: FILE *fp;
143: char c;
144: char rpath[STRLEN];
145: /* char *editor; */
146:
147: if (optc < fma_min_args) {
148: fprintf (stderr, "fmadm: must supply routine name\n");
149: return 1;
150: }
151:
152: snprintf (rpath, STRLEN - 1, "%s/%s.m", fma_routine_path, opts[fma_base_opt]);
153:
154: if (file_exists (rpath) == FALSE) {
155: fprintf (stderr, "fmadm: routine %s does not exist in namespace %s\n", opts[1], fma_namespace);
156: return 1;
157: }
158:
159: if ((fp = fopen (rpath, "r")) == NULL) {
160: fprintf (stderr, "fmadm: could not open routine %s\n", opts[1]);
161: return 1;
162: }
163:
164: while ((c = fgetc (fp)) != EOF) putchar (c);
165:
166: fclose (fp);
167:
168: putchar ('\n');
169:
170: return 0;
171:
172: }
173:
174: int fma_routines_backup (int optc, char **opts)
175: {
176: time_t t = time (NULL);
177: struct tm *buf;
178: char rcmd[STRLEN];
179: char backup_filename[STRLEN];
180: char dtstamp[STRLEN];
181: char bup_path[STRLEN];
182:
183: buf = gmtime (&t);
184:
185: if (optc > 1) {
186: strncpy (bup_path, opts[fma_base_opt], STRLEN - 1);
187: }
188: else {
189: strncpy (bup_path, "/tmp", STRLEN - 1);
190: }
191:
192: snprintf (dtstamp, STRLEN - 1, "%d%02d%02d%02d%02d%02d", buf->tm_year, buf->tm_mon, buf->tm_mday, buf->tm_hour, buf->tm_min, buf->tm_sec);
193: snprintf (backup_filename, STRLEN - 1, "%s/freem-routines-backup-%s-%s.tar", bup_path, fma_namespace, dtstamp);
194:
195: printf ("\nFreeM Routine Backup\n");
196: printf ("--------------------\n\n");
197:
198: printf ("Namespace: %s\n", fma_namespace);
199: printf ("Routine Path: %s\n", fma_routine_path);
200: printf ("Backup Location: %s\n", bup_path);
201: printf ("Backup Filename: %s\n\n", backup_filename);
202:
203: snprintf (rcmd, STRLEN - 1, "tar cvf %s %s/*.m", backup_filename, fma_routine_path);
204: system (rcmd);
205:
206: printf ("\n\nBackup completed.\n\n");
207:
208: return 0;
209:
210: }
211:
212: int fma_routines_restore (int optc, char **opts)
213: {
214: return 0;
215: }
216:
217: char *fma_trim_string(char *str)
218: {
219:
220: char *end;
221:
222: while (isspace ((unsigned char) *str)) str++;
223:
224: if (*str == 0) return str;
225:
226: end = str + strlen (str) - 1;
227:
228: while (end > str && isspace ((unsigned char) *end)) end--;
229:
230: end[1] = '\0';
231:
232: return str;
233:
234: }
235:
236: int fma_routines_import (int optc, char **opts)
237: {
238: int usr_loaded = 0;
239: int pct_loaded = 0;
240: int next_routine_flag = FALSE;
241: int rtn_open = FALSE;
242: int rtn_overwrite = TRUE;
243: long ln = 0;
244:
245: char pct_rtn_path[4096];
246: char usr_rtn_path[4096];
247: char namespace[4096];
248: char roufile[4096];
249: char line[STRLEN];
250: char *trimmed_line;
251:
252: char filename[4096];
253: FILE *archive = NULL;
254: FILE *rtn = NULL;
255:
256: char *parsed_line;
257:
258: strncpy (namespace, fma_namespace, 512 - 1);
259: strncpy (filename, opts[fma_base_opt], 4096 - 1);
260:
261: if (optc < fma_min_args) {
262: fprintf (stderr, "usage: fmadm import routine <namespace> <rsav-file>\n");
263: return 1;
264: }
265:
266: if (strncmp (fma_namespace, "SYSTEM", STRLEN - 1) != 0) {
267:
268: if (get_conf ("SYSTEM", "routines_path", pct_rtn_path) == FALSE) {
269: fprintf (stderr, "fmadm: could not determine percent routine access path from configuration for namespace '%s'.\n", namespace);
270:
271: return 1;
272: }
273:
274: }
275: else {
276: strncpy (pct_rtn_path, fma_routine_path, 4096 - 1);
277: }
278:
279:
280: if (get_conf (namespace, "routines_path", usr_rtn_path) == FALSE) {
281: fprintf (stderr, "fmadm: could not determine user routine access path from configuration for namespace '%s'.\n", namespace);
282:
283: return 1;
284: }
285:
286: if ((archive = fopen (filename, "r")) == NULL) {
287: fprintf (stderr, "fmadm: could not open routine archive '%s'.\n", filename);
288:
289: return 1;
290: }
291:
292: printf ("\nFreeM Routine Import\n");
293: printf ("--------------------\n\n");
294:
295: printf ("Namespace: %s\n", fma_namespace);
296: printf ("Archive: %s\n", filename);
297: printf ("Routine Path: %s\n", usr_rtn_path);
298: printf ("%% Routine Path: %s\n\n", pct_rtn_path);
299:
300: /* read routine archive line-by-line */
301: while (fgets(line, STRLEN - 1, archive) != NULL) {
302:
303: if (line[strlen(line) - 1] == '\n') line[strlen(line) - 1] = '\0';
304:
305: ln++;
306:
307: if ((ln == 1) || (ln == 2)) {
308: printf("%s\n", line);
309: continue;
310: }
311:
312: if (ln == 3) {
313: next_routine_flag = TRUE;
314: }
315:
316: trimmed_line = strdup (line);
317:
318: if (strcmp (fma_trim_string (trimmed_line), "") == 0) {
319:
320: next_routine_flag = TRUE;
321:
322: if(rtn_open == TRUE) {
323: fclose(rtn);
324:
325: rtn_open = FALSE;
326: }
327:
328: continue;
329: }
330:
331: if(next_routine_flag == TRUE) {
332:
333: next_routine_flag = FALSE;
334:
335: parsed_line = strtok (line, "^");
336:
337: if((!isalpha(line[0])) && (line[0] != '%')) {
338:
339: if(rtn_open == TRUE) {
340: fclose(rtn);
341: rtn_open = FALSE;
342: }
343:
344: continue;
345: }
346:
347: printf(" %s\n", parsed_line);
348:
349:
350: switch(line[0]) {
351:
352: case '%':
353: pct_loaded++;
354:
355: snprintf(roufile, PATH_MAX, "%s/%s.m", pct_rtn_path, parsed_line);
356: break;
357:
358: default:
359: usr_loaded++;
360:
361: snprintf(roufile, PATH_MAX, "%s/%s.m", usr_rtn_path, parsed_line);
362: break;
363: }
364:
365: if((file_exists(roufile) == TRUE) && (rtn_overwrite == FALSE)) {
366: fprintf(stdout, "fmadm: routine file '%s' already exists. Will not overwrite.\n", roufile);
367:
368: fclose (archive);
369:
370: return 1;
371: }
372:
373: if((rtn = fopen(roufile, "w")) == NULL) {
374: fprintf(stdout, "fmadm: could not open routine file '%s'.\n", roufile);
375:
376: return 1;
377: }
378: else {
379: rtn_open = TRUE;
380: }
381:
382: }
383: else {
384: if(rtn_open == TRUE) fprintf(rtn, "%s\n", line);
385: }
386:
387: }
388:
389: printf("\n - loaded %d user routines and %d percent routines (%d total)\n\n", usr_loaded, pct_loaded, usr_loaded + pct_loaded);
390:
391: fclose (archive);
392:
393: return 0;
394: }
395:
396: int fma_routines_export (int optc, char **opts)
397: {
398:
399: FILE *out; /* output file handle */
400: DIR *dir; /* namespace directory */
401:
402: struct dirent *ent;
403: char output_file[STRLEN];
404: char routine_spec[STRLEN];
405: char filename[STRLEN];
406: char *rtnname;
407: char *rtnext;
408: int i;
409:
410: int ct = 0;
411:
412:
413: if (optc < fma_min_args) {
414: fprintf (stderr, "usage: fmadm export routine <namespace> <output-file> [routine1 routine2... routineN]\n");
415: return 1;
416: }
417:
418: /* if routines aren't listed, assume we should export entire namespace */
419: if (optc == fma_min_args) {
420: strncpy (routine_spec, "*", STRLEN - 1);
421: }
422:
423: strncpy (output_file, opts[1], STRLEN - 1);
424: strncpy (routine_spec, opts[2], STRLEN - 1);
425:
426: if (file_exists (output_file) == TRUE) {
427: fprintf (stderr, "fmadm: output file %s already exists\n", output_file);
428: return 1;
429: }
430:
431: if ((out = fopen(output_file, "w")) == NULL) {
432: fprintf (stderr, "fmadm: could not open output file %s for writing\n", output_file);
433: return 1;
434: }
435:
436:
437: printf ("\nFreeM Routine Export\n");
438: printf ("--------------------\n\n");
439:
440: printf ("Namespace: %s\n", fma_namespace);
441: printf ("Routine Path: %s\n", fma_routine_path);
442: printf ("Output File: %s\n", output_file);
443: printf ("Routines Selected: ");
444:
445: if (optc == 2) {
446: printf ("[ENTIRE NAMESPACE]\n\n");
447: }
448: else {
449: for (i = 2; i < optc; i++) {
450: printf ("%s ", opts[i]);
451: }
452:
453: printf ("\n\n");
454: }
455:
456: fprintf (out, "Routines\n");
457:
458: if (optc == 2) {
459:
460: /* export entire namespace */
461:
462: if ((dir = opendir (fma_routine_path)) == NULL) {
463: fprintf (stderr, "fmadm: could not open routine directory %s\n", fma_routine_path);
464: fclose (out);
465: return 1;
466: }
467:
468: while ((ent = readdir (dir)) != NULL) {
469:
470: strncpy (filename, ent->d_name, STRLEN - 1);
471:
472: rtnname = strtok (filename, ".");
473: rtnext = strtok (NULL, ".");
474:
475: if (rtnext != NULL && strncmp (rtnext, "m", STRLEN - 1) == 0) {
476: ct += fma_do_export (out, rtnname);
477: }
478:
479: }
480:
481: closedir (dir);
482:
483: }
484: else {
485:
486: /* export only selected routines */
487: for (i = fma_base_opt + 1; i < optc; i++) {
488: ct += fma_do_export (out, opts[i]);
489: }
490:
491: }
492:
493: printf ("\n\n - %d routines exported\n\n", ct);
494:
495: fclose (out);
496:
497: return 0;
498:
499: }
500:
501: int fma_do_export (FILE *out, char *rtn_name)
502: {
503: FILE *in;
504: char rtnfile[STRLEN];
505: char line[FM_STR_MAX];
506:
507: snprintf (rtnfile, STRLEN - 1, "%s/%s.m", fma_routine_path, rtn_name);
508:
509: printf (" Exporting %-10s\t", rtn_name);
510:
511: if ((in = fopen (rtnfile, "r")) == NULL) {
512: printf ("[FAIL]\n");
513: return 0;
514: }
515:
516: fprintf (out, "\n%s\n", rtn_name);
517:
518: while (fgets (line, FM_STR_MAX, in) != NULL) {
519: fprintf (out, "%s", line);
520: }
521:
522: printf ("[OK]\n");
523:
524: fprintf (out, "\n");
525:
526: fclose (in);
527:
528: return 1;
529: }
530:
531: int fma_routines_create (int optc, char **opts)
532: {
533: return 0;
534: }
535:
536: int fma_routines_remove (int optc, char **opts)
537: {
538:
539: char rpath[STRLEN];
540: int i;
541: int ct = 0;
542: int er = 0;
543: int tot = 0;
544:
545: printf ("\nFreeM Routine Removal\n");
546: printf ("---------------------\n\n");
547:
548: printf ("Namespace: %s\n", fma_namespace);
549: printf ("Routine Path: %s\n\n", fma_routine_path);
550:
551: for (i = fma_base_opt; i < optc; i++) {
552: printf ("%-10s\t", opts[i]);
553:
554: snprintf (rpath, STRLEN - 1, "%s/%s.m", fma_routine_path, opts[i]);
555:
556: if (unlink (rpath) == -1) {
557: printf ("[FAIL]\n");
558: er++;
559: }
560: else {
561: printf ("[OK]\n");
562: ct++;
563: }
564:
565: tot++;
566:
567: }
568:
569: printf ("\nRemoved %d routines [%d errors/%d attempted]\n\n", ct, er, tot);
570:
571: return 0;
572:
573: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fma_routines.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src