Annotation of freem/src/iniconf.c, revision 1.4
1.1 snw 1: /*
1.4 ! snw 2: * $Id: iniconf.c,v 1.3 2025/03/09 19:14:25 snw Exp $
1.1 snw 3: * Function implementations for reading
4: * FreeM configuration files
5: *
6: *
1.2 snw 7: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 8: * Copyright (C) 1998 MUG Deutschland
1.3 snw 9: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 10: *
11: *
12: * This file is part of FreeM.
13: *
14: * FreeM is free software: you can redistribute it and/or modify
15: * it under the terms of the GNU Affero Public License as published by
16: * the Free Software Foundation, either version 3 of the License, or
17: * (at your option) any later version.
18: *
19: * FreeM is distributed in the hope that it will be useful,
20: * but WITHOUT ANY WARRANTY; without even the implied warranty of
21: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22: * GNU Affero Public License for more details.
23: *
24: * You should have received a copy of the GNU Affero Public License
25: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
26: *
1.4 ! snw 27: * $Log: iniconf.c,v $
! 28: * Revision 1.3 2025/03/09 19:14:25 snw
! 29: * First phase of REUSE compliance and header reformat
! 30: *
1.3 snw 31: *
32: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
33: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 34: **/
35:
36: #define FALSE 0
37: #define TRUE 1
38: #include <stddef.h>
39: #include "iniconf.h"
40: #include "libfill.h"
41: #include <stdio.h>
42: #include <unistd.h>
43: #include <sys/types.h>
44: #include <pwd.h>
45: #include <string.h>
46: #include <limits.h>
1.4 ! snw 47: #include <fs.h>
1.1 snw 48: #include "mpsdef.h"
49:
50: extern char config_file[4096];
51:
52: #if !defined(PATH_MAX) && defined(_SCO_DS)
53: # define PATH_MAX 4096
54: #endif
55:
56: #if !defined(PATH_MAX) && defined(__gnu_hurd__)
57: # define PATH_MAX 1024
58: #endif
59:
60: #if !defined(PATH_MAX) && defined(_AIX)
61: # define PATH_MAX 1024
62: #endif
63:
64: #if defined(__NetBSD__) || defined(__FreeBSD__)
65: # include <sys/syslimits.h>
66: #endif
67:
68: ini_keyvalue *ini_head;
69:
70: int get_conf(char *section, char *key, char *value)
71: {
72: char *etcfile;
73: char *dotfile;
74: char *homedir;
75:
76: int exists_in_etc = FALSE;
77: int exists_in_dotfile = FALSE;
78: int dotexists;
79: int etcexists;
80:
81: char *etc_value;
82: char *dot_value;
83:
84: etc_value = (char *) malloc(CONF_BUFSIZE);
85: NULLPTRCHK(etc_value,"get_conf");
86: dot_value = (char *) malloc(CONF_BUFSIZE);
87: NULLPTRCHK(dot_value,"get_conf");
88:
89: etcfile = config_file;
90:
91:
92: #if !defined(__AMIGA) && !defined(_SCO_DS) && !defined(_AIX)
93: uid_t uid = geteuid();
94: struct passwd *pw = getpwuid(uid);
95:
96: if (pw == NULL) {
97: free (etc_value);
98: free (dot_value);
99:
100: return (FALSE);
101: }
102:
103: homedir = (char *) calloc(strlen(pw->pw_dir) + 1, sizeof(char));
104: NULLPTRCHK(homedir,"get_conf");
105:
106: (void) strcpy(homedir, pw->pw_dir);
107:
108: dotfile = calloc(PATH_MAX, sizeof(char));
109: NULLPTRCHK(dotfile,"get_conf");
110:
111: (void) strcat(dotfile, homedir);
112: (void) strcat(dotfile, "/.freemrc");
113:
114: etcexists = file_exists(etcfile);
115: dotexists = file_exists(dotfile);
116: #else
117:
118: #if defined(__AMIGA)
119: strcpy (etcfile, "./freem.conf");
120: etcexists = TRUE;
121: dotexists = FALSE;
122: #else
123: strcpy (etcfile, SYSCONFDIR"/freem.conf");
124:
125: etcexists = TRUE;
126: dotexists = FALSE;
127: #endif
128:
129: #endif
130:
131: if (etcexists == TRUE) {
132: exists_in_etc = read_profile_string(etcfile, section, key, etc_value);
133: }
134: else {
135: exists_in_etc = FALSE;
136: }
137:
138: if (dotexists == TRUE) {
139: exists_in_dotfile = read_profile_string(dotfile, section, key, dot_value);
140: }
141: else {
142: exists_in_dotfile = FALSE;
143: }
144:
145: if (exists_in_dotfile) {
146: strcpy (value, dot_value);
147:
148: free (etc_value);
149: free (dot_value);
150: #if !defined(__AMIGA) && !defined(_SCO_DS) && !defined(_AIX)
151: free (homedir);
152: free (dotfile);
153: #endif
154:
155: return (TRUE);
156: }
157:
158: if (exists_in_etc) {
159: strcpy(value, etc_value);
160:
161: free (etc_value);
162: free (dot_value);
163: #if !defined(__AMIGA) && !defined(_SCO_DS) && !defined(_AIX)
164: free (homedir);
165: free (dotfile);
166: #endif
167:
168: return (TRUE);
169: }
170:
171: free (etc_value);
172: free (dot_value);
173: #if !defined(__AMIGA) && !defined(_SCO_DS) && !defined(_AIX)
174: free (homedir);
175: free (dotfile);
176: #endif
177:
178: return (FALSE); /* didn't exist anywhere */
179: }
180:
181: int read_profile_string(char *file, char *section, char *key, char *value)
182: {
183:
184: register int i;
185:
186: FILE *fp;
187:
188: char *curkey;
189: char *curval;
190: char *fullsec;
191: char *cursec;
192: char *line;
193: int lnum = 0;
194:
195: fullsec = (char *) malloc(CONF_BUFSIZE);
196: NULLPTRCHK(fullsec,"read_profile_string");
197:
198: cursec = (char *) malloc(CONF_BUFSIZE);
199: NULLPTRCHK(cursec,"read_profile_string");
200:
201: line = (char *) malloc(CONF_BUFSIZE);
202: NULLPTRCHK(line,"read_profile_string");
203:
204:
205:
206:
207: snprintf(fullsec, CONF_BUFSIZE, "[%s]%c", section, '\0');
208:
209: strcpy(cursec, "[]");
210:
211:
212: fp = fopen(file, "r");
213:
214: while(fgets(line, CONF_BUFSIZE, fp) != NULL) {
215: ++lnum;
216:
217: if(line[0] == '[') {
218: strcpy(cursec, line);
219:
220: for(i = 0; i < CONF_BUFSIZE; i++) {
221: if(cursec[i] == ']') {
222: cursec[i + 1] = '\0';
223: break;
224: }
225: }
226: }
227: else {
228: if ((line[0] != '[') && (strchr(line, '=') != NULL)) {
229: curkey = strtok(line, "=");
230: curval = strtok(NULL, "=");
231: curval = strtok(curval, "\n");
232:
233:
234: if((strcmp(curkey, key) == 0) && (strcmp(cursec, fullsec) == 0)) {
235: strcpy(value, curval);
236: (void) fclose(fp);
237:
238: free (fullsec);
239: free (curkey);
240: free (cursec);
241:
242: return(TRUE);
243: }
244: }
245: }
246:
247: }
248:
249: if (fp != NULL) {
250: (void) fclose(fp);
251: }
252:
253: /* if we've gotten here, the section and/or key was not found */
254: sprintf (value, "\0");
255:
256: free (fullsec);
257: free (curkey);
258: free (cursec);
259:
260: return(FALSE);
261:
262: }
263:
264: int file_exists(char *filename)
265: {
266: FILE *fp;
267:
268: if ((fp = fopen(filename, "r")) != NULL) {
269: (void) fclose(fp);
270:
271: return(TRUE);
272: }
273: else {
274: return(FALSE);
275: }
276: }
277:
278: void write_profile_string(char *file, char *section, char *key, char *value)
279: {
1.4 ! snw 280: ini_keyvalue *ini_head;
! 281: }
! 282:
! 283: void parse_section_header(char *input, char *buf, size_t buflen)
! 284: {
! 285: strncpy (buf, &(input[1]), buflen);
! 286: buf[strlen (buf) - 2] = '\0';
! 287: }
! 288:
! 289: int modify_profile_string(char *file, char *section, char *key, char *value)
! 290: {
! 291: FILE *input_fp;
! 292: FILE *output_fp;
! 293: char output_filename[4096];
! 294: char input_line[255];
! 295: char output_line[255];
! 296: char current_section[255];
! 297: char *savptr;
! 298: char *current_key;
! 299: char *current_value;
! 300: char tmpsi[255];
! 301: char tmps[255];
! 302: int changed = FALSE;
! 303:
! 304: snprintf (output_filename, 4095, "%s.tmp", file);
! 305:
! 306: if ((input_fp = fopen (file, "r")) == NULL) {
! 307: return FALSE;
! 308: }
! 309:
! 310: if ((output_fp = fopen (output_filename, "w+")) == NULL) {
! 311: fclose (input_fp);
! 312: return FALSE;
! 313: }
! 314:
! 315: while (fgets (input_line, 255, input_fp)) {
! 316: if (input_line[0] == '[') {
! 317: /* this is a section; write it unchanged */
! 318: fputs (input_line, output_fp);
! 319:
! 320: /* update the current section */
! 321: parse_section_header (input_line, current_section, 255);
! 322: }
! 323: else {
! 324: /* is this a key/value pair? */
! 325: if (strchr (input_line, '=') != NULL) {
! 326: /* are we in the requested section? */
! 327: if (strcmp (section, current_section) == 0) {
! 328: /* yes; we'll parse it */
! 329: strcpy (tmpsi, input_line);
! 330: savptr = tmpsi;
! 331: current_key = strtok_r (tmpsi, "=", &savptr);
! 332: current_value = strtok_r (NULL, "=", &savptr);
! 333: /* is this key the one we're changing? */
! 334: if (strcmp (key, current_key) == 0) {
! 335: /* yes; modify it and write out*/
! 336: snprintf (tmps, 255, "%s=%s\n", current_key, value);
! 337:
! 338: fputs (tmps, output_fp);
! 339: changed = TRUE;
! 340: }
! 341: else {
! 342: /* not the requested key; pass it through unmodified */
! 343: fputs (input_line, output_fp);
! 344: }
! 345: }
! 346: else {
! 347: /* not the requested section; write it out unchanged */
! 348: fputs (input_line, output_fp);
! 349: }
! 350: }
! 351: else {
! 352: /* not a key/value pair; write it out unchanged */
! 353: fputs (input_line, output_fp);
! 354: }
! 355: }
! 356: }
! 357:
! 358: /* close both files */
! 359: fclose (output_fp);
! 360: fclose (input_fp);
! 361:
! 362: /* delete the original file */
! 363: unlink (file);
! 364:
! 365: /* rename the temporary file */
! 366: #if !defined(__OS2__)
! 367: cp (file, output_filename);
! 368: #else
! 369: DosCopy (output_filename, file);
! 370: #endif
! 371:
! 372: return changed;
1.1 snw 373: }
374:
1.4 ! snw 375:
1.1 snw 376: ini_keyvalue *ini_insert(ini_section *s, char *section, char *key, char *value)
377: {
378: ini_section *t;
379:
380: for (t = s; t != NULL; t = t->next) {
381:
382: if (strcmp (t->name, section) == 0) {
383:
384: /* this section already exists. update. */
385: return ini_kv_insert (s, key, value);
386:
387: }
388:
389: }
390:
391: /* section does not exist. insert. */
392: t = (ini_section *) malloc (sizeof (ini_section));
393: NULLPTRCHK(t,"ini_insert");
394:
395: t->name = (char *) malloc ((strlen (section) + 1) * sizeof (char));
396: NULLPTRCHK(t->name,"ini_insert");
397:
398: strcpy (t->name, section);
399:
400: t->next = s;
401: s = t;
402:
403: return ini_kv_insert (s, key, value);
404:
405: }
406:
407: ini_keyvalue *ini_kv_insert(ini_section *s, char *key, char *value)
408: {
409: ini_keyvalue *t;
410:
411: for (t = s->head; t != NULL; t = t->next) {
412:
413: if (strcmp (t->key, key) == 0) {
414:
415: /* this is an update */
416: free (t->value);
417: t->value = (char *) malloc ((strlen (value) + 1) * sizeof (char));
418: NULLPTRCHK(t->value,"ini_kv_insert");
419:
420: strcpy (t->value, value);
421:
422: return t;
423:
424: }
425:
426: }
427:
428: /* this is an insert */
429: t = (ini_keyvalue *) malloc (sizeof (ini_keyvalue));
430: NULLPTRCHK(t,"ini_kv_insert");
431:
432: t->key = (char *) malloc ((strlen (key) + 1) * sizeof (char));
433: NULLPTRCHK(t->key,"ini_kv_insert");
434:
435: t->value = (char *) malloc ((strlen (value) + 1) * sizeof (char));
436: NULLPTRCHK(t->value,"ini_kv_insert");
437:
438: strcpy (t->key, key);
439: strcpy (t->value, value);
440:
441: t->next = s->head;
442: s->head = t;
443:
444: return t;
445:
446: }
447:
448: void ini_section_delete(ini_section *head, char *name)
449: {
450: ini_section *t = head;
451: ini_section *p = NULL;
452:
453: if ((t != (ini_section *) NULL) && (strcmp (t->name, name) == 0)) {
454: head = t->next;
455:
456: free (t->name);
457: free (t);
458: return;
459: }
460:
461: while ((t != NULL) && (strcmp (t->name, name) != 0)) {
462: p = t;
463: t = t->next;
464: }
465:
466: if (t == NULL) return;
467:
468: free (t->name);
469: free (t);
470:
471: return;
472: }
473:
474: void ini_key_delete(ini_section *head, char *key)
475: {
476:
477: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iniconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src