![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ini_file.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / xpdev|
Return to ini_file.c CVS log | Up to [Synchronet] / sbbs / xpdev |
1.1 root 1: /* ini_file.c */
2:
3: /* Functions to parse ini files */
4:
5: /* $Id: ini_file.c,v 1.63 2004/12/23 22:26:44 rswindell Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2004 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This library is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU Lesser General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU Lesser General Public License for more details: lgpl.txt or *
18: * http://www.fsf.org/copyleft/lesser.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include <stdlib.h> /* strtol */
39: #include <string.h> /* strlen */
40: #include <ctype.h> /* isdigit */
41: #if !defined(NO_SOCKET_SUPPORT)
42: #include "sockwrap.h" /* inet_addr */
43: #endif
44: #include "dirwrap.h" /* fexist */
45: #include "filewrap.h" /* chsize */
46: #include "ini_file.h"
47:
48: /* Maximum length of entire line, includes '\0' */
49: #define INI_MAX_LINE_LEN (INI_MAX_VALUE_LEN*2)
50: #define INI_COMMENT_CHAR ';'
51: #define INI_OPEN_SECTION_CHAR '['
52: #define INI_CLOSE_SECTION_CHAR ']'
53: #define INI_NEW_SECTION ((char*)~0)
54:
55: static ini_style_t default_style;
56:
57: static char* section_name(char* p)
58: {
59: char* tp;
60:
61: SKIP_WHITESPACE(p);
62: if(*p!=INI_OPEN_SECTION_CHAR)
63: return(NULL);
64: p++;
65: SKIP_WHITESPACE(p);
66: tp=strrchr(p,INI_CLOSE_SECTION_CHAR);
67: if(tp==NULL)
68: return(NULL);
69: *tp=0;
70: truncsp(p);
71:
72: return(p);
73: }
74:
75: static BOOL seek_section(FILE* fp, const char* section)
76: {
77: char* p;
78: char str[INI_MAX_LINE_LEN];
79:
80: rewind(fp);
81:
82: if(section==ROOT_SECTION)
83: return(TRUE);
84:
85: while(!feof(fp)) {
86: if(fgets(str,sizeof(str),fp)==NULL)
87: break;
88: if((p=section_name(str))==NULL)
89: continue;
90: if(stricmp(p,section)==0)
91: return(TRUE);
92: }
93: return(FALSE);
94: }
95:
96: static size_t find_section_index(str_list_t list, const char* section)
97: {
98: char* p;
99: char str[INI_MAX_VALUE_LEN];
100: size_t i;
101:
102: for(i=0; list[i]!=NULL; i++) {
103: SAFECOPY(str,list[i]);
104: if((p=section_name(str))!=NULL && stricmp(p,section)==0)
105: return(i);
106: }
107:
108: return(i);
109: }
110:
111: static size_t find_section(str_list_t list, const char* section)
112: {
113: size_t i;
114:
115: if(section==ROOT_SECTION)
116: return(0);
117:
118: i=find_section_index(list,section);
119: if(list[i]!=NULL)
120: i++;
121: return(i);
122: }
123:
124: static char* key_name(char* p, char** vp)
125: {
126: char* equal;
127: char* colon;
128:
129: *vp=NULL;
130:
131: if(p==NULL)
132: return(NULL);
133:
134: /* Parse value name */
135: SKIP_WHITESPACE(p);
136: if(*p==INI_COMMENT_CHAR)
137: return(NULL);
138: if(*p==INI_OPEN_SECTION_CHAR)
139: return(INI_NEW_SECTION);
140: equal=strchr(p,'=');
141: colon=strchr(p,':');
142: if(colon==NULL || (equal!=NULL && equal<colon)) {
143: *vp=equal;
144: colon=NULL;
145: } else
146: *vp=colon;
147:
148: if(*vp==NULL)
149: return(NULL);
150:
151: *(*vp)=0;
152: truncsp(p);
153:
154: /* Parse value */
155: (*vp)++;
156: SKIP_WHITESPACE(*vp);
157: if(colon!=NULL)
158: truncnl(*vp); /* "key : value" - truncate new-line chars only */
159: else
160: truncsp(*vp); /* "key = value" - truncate all white-space chars */
161:
162: return(p);
163: }
164:
165: static char* read_value(FILE* fp, const char* section, const char* key, char* value)
166: {
167: char* p;
168: char* vp=NULL;
169: char str[INI_MAX_LINE_LEN];
170:
171: if(fp==NULL)
172: return(NULL);
173:
174: if(!seek_section(fp,section))
175: return(NULL);
176:
177: while(!feof(fp)) {
178: if(fgets(str,sizeof(str),fp)==NULL)
179: break;
180: if((p=key_name(str,&vp))==NULL)
181: continue;
182: if(p==INI_NEW_SECTION)
183: break;
184: if(stricmp(p,key)!=0)
185: continue;
186: if(vp==NULL)
187: break;
188: /* key found */
189: sprintf(value,"%.*s",INI_MAX_VALUE_LEN-1,vp);
190: return(value);
191: }
192:
193: return(NULL);
194: }
195:
196: static size_t get_value(str_list_t list, const char* section, const char* key, char* value)
197: {
198: char str[INI_MAX_LINE_LEN];
199: char* p;
200: char* vp;
201: size_t i;
202:
203: value[0]=0;
204: for(i=find_section(list, section); list[i]!=NULL; i++) {
205: SAFECOPY(str, list[i]);
206: if((p=key_name(str,&vp))==NULL)
207: continue;
208: if(p==INI_NEW_SECTION)
209: break;
210: if(stricmp(p,key)!=0)
211: continue;
212: sprintf(value,"%.*s",INI_MAX_VALUE_LEN-1,vp);
213: return(i);
214: }
215:
216: return(i);
217: }
218:
219: BOOL iniSectionExists(str_list_t* list, const char* section)
220: {
221: size_t i;
222:
223: if(section==ROOT_SECTION)
224: return(TRUE);
225:
226: i=find_section_index(*list,section);
227: return((*list)[i]!=NULL);
228: }
229:
230: BOOL iniKeyExists(str_list_t* list, const char* section, const char* key)
231: {
232: char val[INI_MAX_VALUE_LEN];
233: size_t i;
234:
235: i=get_value(*list, section, key, val);
236:
237: if((*list)[i]==NULL || *(*list)[i]==INI_OPEN_SECTION_CHAR)
238: return(FALSE);
239:
240: return(TRUE);
241: }
242:
243: BOOL iniValueExists(str_list_t* list, const char* section, const char* key)
244: {
245: char val[INI_MAX_VALUE_LEN];
246:
247: get_value(*list, section, key, val);
248:
249: return(val[0]!=0);
250: }
251:
252: BOOL iniRemoveKey(str_list_t* list, const char* section, const char* key)
253: {
254: char val[INI_MAX_VALUE_LEN];
255: size_t i;
256:
257: i=get_value(*list, section, key, val);
258:
259: if((*list)[i]==NULL || *(*list)[i]==INI_OPEN_SECTION_CHAR)
260: return(FALSE);
261:
262: return(strListDelete(list,i));
263: }
264:
265: BOOL iniRemoveValue(str_list_t* list, const char* section, const char* key)
266: {
267: char val[INI_MAX_VALUE_LEN];
268: size_t i;
269: char* p;
270: char* vp=NULL;
271:
272: i=get_value(*list, section, key, val);
273:
274: p=key_name((*list)[i], &vp);
275: if(vp==NULL)
276: return(FALSE);
277:
278: strcat(p,"=");
279: return(TRUE);
280: }
281:
282: BOOL iniRemoveSection(str_list_t* list, const char* section)
283: {
284: size_t i;
285:
286: i=find_section_index(*list,section);
287: if((*list)[i]==NULL) /* not found */
288: return(FALSE);
289: do {
290: strListDelete(list,i);
291: } while((*list)[i]!=NULL && *(*list)[i]!=INI_OPEN_SECTION_CHAR);
292:
293: return(TRUE);
294: }
295:
296: BOOL iniRenameSection(str_list_t* list, const char* section, const char* newname)
297: {
298: char str[INI_MAX_LINE_LEN];
299: size_t i;
300:
301: if(section==ROOT_SECTION)
302: return(FALSE);
303:
304: i=find_section_index(*list,newname);
305: if((*list)[i]!=NULL) /* duplicate */
306: return(FALSE);
307:
308: i=find_section_index(*list,section);
309: if((*list)[i]==NULL) /* not found */
310: return(FALSE);
311:
312: SAFEPRINTF(str,"[%s]",newname);
313: return(strListReplace(*list, i, str)!=NULL);
314: }
315:
316: size_t iniAddSection(str_list_t* list, const char* section
317: ,ini_style_t* style)
318: {
319: char str[INI_MAX_LINE_LEN];
320: size_t i;
321:
322: if(section==ROOT_SECTION)
323: return(0);
324:
325: i=find_section_index(*list, section);
326: if((*list)[i]==NULL) {
327: if(style==NULL)
328: style=&default_style;
329: if(style->section_separator!=NULL)
330: strListAppend(list, style->section_separator, i++);
331: SAFEPRINTF(str,"[%s]",section);
332: strListAppend(list, str, i);
333: }
334:
335: return(i);
336: }
337:
338: char* iniSetString(str_list_t* list, const char* section, const char* key, const char* value
339: ,ini_style_t* style)
340: {
341: char str[INI_MAX_LINE_LEN];
342: char curval[INI_MAX_VALUE_LEN];
343: size_t i;
344:
345: if(style==NULL)
346: style=&default_style;
347:
348: iniAddSection(list, section, style);
349:
350: if(key==NULL)
351: return(NULL);
352: if(style->key_prefix==NULL)
353: style->key_prefix="";
354: if(style->value_separator==NULL)
355: style->value_separator="=";
356: if(value==NULL)
357: value="";
358: safe_snprintf(str, sizeof(str), "%s%-*s%s%s"
359: , style->key_prefix, style->key_len, key, style->value_separator, value);
360: i=get_value(*list, section, key, curval);
361: if((*list)[i]==NULL || *(*list)[i]==INI_OPEN_SECTION_CHAR) {
362: while(i && *(*list)[i-1]==0) i--; /* Insert before blank lines, not after */
363: return strListInsert(list, str, i);
364: }
365:
366: if(strcmp(curval,value)==0)
367: return((*list)[i]); /* no change */
368:
369: return strListReplace(*list, i, str);
370: }
371:
372: char* iniSetInteger(str_list_t* list, const char* section, const char* key, long value
373: ,ini_style_t* style)
374: {
375: char str[INI_MAX_VALUE_LEN];
376:
377: SAFEPRINTF(str,"%ld",value);
378: return iniSetString(list, section, key, str, style);
379: }
380:
381: char* iniSetShortInt(str_list_t* list, const char* section, const char* key, ushort value
382: ,ini_style_t* style)
383: {
384: char str[INI_MAX_VALUE_LEN];
385:
386: SAFEPRINTF(str,"%hu",value);
387: return iniSetString(list, section, key, str, style);
388: }
389:
390: char* iniSetHexInt(str_list_t* list, const char* section, const char* key, ulong value
391: ,ini_style_t* style)
392: {
393: char str[INI_MAX_VALUE_LEN];
394:
395: SAFEPRINTF(str,"0x%lx",value);
396: return iniSetString(list, section, key, str, style);
397: }
398:
399: char* iniSetFloat(str_list_t* list, const char* section, const char* key, double value
400: ,ini_style_t* style)
401: {
402: char str[INI_MAX_VALUE_LEN];
403:
404: SAFEPRINTF(str,"%g",value);
405: return iniSetString(list, section, key, str, style);
406: }
407:
408: #if !defined(NO_SOCKET_SUPPORT)
409: char* iniSetIpAddress(str_list_t* list, const char* section, const char* key, ulong value
410: ,ini_style_t* style)
411: {
412: struct in_addr in_addr;
413: in_addr.s_addr=htonl(value);
414: return iniSetString(list, section, key, inet_ntoa(in_addr), style);
415: }
416: #endif
417:
418: char* iniSetBool(str_list_t* list, const char* section, const char* key, BOOL value
419: ,ini_style_t* style)
420: {
421: return iniSetString(list, section, key, value ? "true":"false", style);
422: }
423:
424: char* iniSetBitField(str_list_t* list, const char* section, const char* key
425: ,ini_bitdesc_t* bitdesc, ulong value, ini_style_t* style)
426: {
427: char str[INI_MAX_VALUE_LEN];
428: int i;
429:
430: if(style==NULL)
431: style=&default_style;
432: if(style->bit_separator==NULL)
433: style->bit_separator="|";
434: str[0]=0;
435: for(i=0;bitdesc[i].name;i++) {
436: if((value&bitdesc[i].bit)==0)
437: continue;
438: if(str[0])
439: strcat(str,style->bit_separator);
440: strcat(str,bitdesc[i].name);
441: value&=~bitdesc[i].bit;
442: }
443: if(value) { /* left over bits? */
444: if(str[0])
445: strcat(str,style->bit_separator);
446: sprintf(str+strlen(str), "0x%lX", value);
447: }
448: return iniSetString(list, section, key, str, style);
449: }
450:
451: char* iniSetStringList(str_list_t* list, const char* section, const char* key
452: ,const char* sep, str_list_t val_list, ini_style_t* style)
453: {
454: char value[INI_MAX_VALUE_LEN];
455: size_t i;
456:
457: value[0]=0;
458:
459: if(sep==NULL)
460: sep=",";
461:
462: if(val_list!=NULL)
463: for(i=0; val_list[i]!=NULL; i++) {
464: if(value[0])
465: strcat(value,sep);
466: strcat(value,val_list[i]);
467: }
468:
469: return iniSetString(list, section, key, value, style);
470: }
471:
472: char* iniReadString(FILE* fp, const char* section, const char* key, const char* deflt, char* value)
473: {
474: if(read_value(fp,section,key,value)==NULL || *value==0 /* blank */) {
475: if(deflt==NULL)
476: return(NULL);
477: sprintf(value,"%.*s",INI_MAX_VALUE_LEN-1,deflt);
478: }
479:
480: return(value);
481: }
482:
483: char* iniGetString(str_list_t* list, const char* section, const char* key, const char* deflt, char* value)
484: {
485: get_value(*list, section, key, value);
486:
487: if(*value==0 /* blank */) {
488: if(deflt==NULL)
489: return(NULL);
490: sprintf(value,"%.*s",INI_MAX_VALUE_LEN-1,deflt);
491: }
492:
493: return(value);
494: }
495:
496: static str_list_t splitList(char* list, const char* sep)
497: {
498: char* token;
499: ulong items=0;
500: str_list_t lp;
501:
502: if((lp=strListInit())==NULL)
503: return(NULL);
504:
505: if(sep==NULL)
506: sep=",";
507:
508: token=strtok(list,sep);
509: while(token!=NULL) {
510: SKIP_WHITESPACE(token);
511: truncsp(token);
512: if(strListAppend(&lp,token,items++)==NULL)
513: break;
514: token=strtok(NULL,sep);
515: }
516:
517: return(lp);
518: }
519:
520: str_list_t iniReadStringList(FILE* fp, const char* section, const char* key
521: ,const char* sep, const char* deflt)
522: {
523: char* value;
524: char buf[INI_MAX_VALUE_LEN];
525: char list[INI_MAX_VALUE_LEN];
526:
527: if((value=read_value(fp,section,key,buf))==NULL || *value==0 /* blank */)
528: value=(char*)deflt;
529:
530: if(value==NULL)
531: return(NULL);
532:
533: SAFECOPY(list,value);
534:
535: return(splitList(list,sep));
536: }
537:
538: str_list_t iniGetStringList(str_list_t* list, const char* section, const char* key
539: ,const char* sep, const char* deflt)
540: {
541: char buf[INI_MAX_VALUE_LEN];
542: char* value=buf;
543:
544: get_value(*list, section, key, value);
545:
546: if(*value==0 /* blank */)
547: value=(char*)deflt;
548:
549: SAFECOPY(buf,value);
550:
551: return(splitList(buf,sep));
552: }
553:
554: void* iniFreeStringList(str_list_t list)
555: {
556: strListFree(&list);
557: return(list);
558: }
559:
560: void* iniFreeNamedStringList(named_string_t** list)
561: {
562: ulong i;
563:
564: if(list==NULL)
565: return(NULL);
566:
567: for(i=0;list[i]!=NULL;i++) {
568: if(list[i]->name!=NULL)
569: free(list[i]->name);
570: if(list[i]->value!=NULL)
571: free(list[i]->value);
572: free(list[i]);
573: }
574:
575: free(list);
576: return(NULL);
577: }
578:
579: str_list_t iniReadSectionList(FILE* fp, const char* prefix)
580: {
581: char* p;
582: char str[INI_MAX_LINE_LEN];
583: ulong items=0;
584: str_list_t lp;
585:
586: if((lp=strListInit())==NULL)
587: return(NULL);
588:
589: if(fp==NULL)
590: return(lp);
591:
592: rewind(fp);
593:
594: while(!feof(fp)) {
595: if(fgets(str,sizeof(str),fp)==NULL)
596: break;
597: if((p=section_name(str))==NULL)
598: continue;
599: if(prefix!=NULL)
600: if(strnicmp(p,prefix,strlen(prefix))!=0)
601: continue;
602: if(strListAppend(&lp,p,items++)==NULL)
603: break;
604: }
605:
606: return(lp);
607: }
608:
609: str_list_t iniGetSectionList(str_list_t* list, const char* prefix)
610: {
611: char* p;
612: char str[INI_MAX_LINE_LEN];
613: ulong i,items=0;
614: str_list_t lp;
615:
616: if((lp=strListInit())==NULL)
617: return(NULL);
618:
619: if(list==NULL)
620: return(lp);
621:
622: for(i=0;list[i];i++) {
623: SAFECOPY(str,list[i]);
624: if((p=section_name(str))==NULL)
625: continue;
626: if(prefix!=NULL)
627: if(strnicmp(p,prefix,strlen(prefix))!=0)
628: continue;
629: if(strListAppend(&lp,p,items++)==NULL)
630: break;
631: }
632:
633: return(lp);
634: }
635:
636: str_list_t iniReadKeyList(FILE* fp, const char* section)
637: {
638: char* p;
639: char* vp;
640: char str[INI_MAX_LINE_LEN];
641: ulong items=0;
642: str_list_t lp;
643:
644: if((lp=strListInit())==NULL)
645: return(NULL);
646:
647: if(fp==NULL)
648: return(lp);
649:
650: rewind(fp);
651:
652: if(!seek_section(fp,section))
653: return(lp);
654:
655: while(!feof(fp)) {
656: if(fgets(str,sizeof(str),fp)==NULL)
657: break;
658: if((p=key_name(str,&vp))==NULL)
659: continue;
660: if(p==INI_NEW_SECTION)
661: break;
662: if(strListAppend(&lp,p,items++)==NULL)
663: break;
664: }
665:
666: return(lp);
667: }
668:
669: str_list_t iniGetKeyList(str_list_t* list, const char* section)
670: {
671: char* p;
672: char* vp;
673: char str[INI_MAX_LINE_LEN];
674: ulong i,items=0;
675: str_list_t lp;
676:
677: if((lp=strListInit())==NULL)
678: return(NULL);
679:
680: if(list==NULL)
681: return(lp);
682:
683: for(i=find_section(*list,section);list[i]==NULL;i++) {
684: SAFECOPY(str,list[i]);
685: if((p=key_name(str,&vp))==NULL)
686: continue;
687: if(p==INI_NEW_SECTION)
688: break;
689: if(strListAppend(&lp,p,items++)==NULL)
690: break;
691: }
692:
693: return(lp);
694: }
695:
696:
697: named_string_t**
698: iniReadNamedStringList(FILE* fp, const char* section)
699: {
700: char* name;
701: char* value;
702: char str[INI_MAX_LINE_LEN];
703: ulong items=0;
704: named_string_t** lp;
705: named_string_t** np;
706:
707: if((lp=(named_string_t**)malloc(sizeof(named_string_t*)))==NULL)
708: return(NULL);
709:
710: *lp=NULL;
711:
712: if(fp==NULL)
713: return(lp);
714:
715: rewind(fp);
716:
717: if(!seek_section(fp,section))
718: return(lp);
719:
720: while(!feof(fp)) {
721: if(fgets(str,sizeof(str),fp)==NULL)
722: break;
723: if((name=key_name(str,&value))==NULL)
724: continue;
725: if(name==INI_NEW_SECTION)
726: break;
727: if((np=(named_string_t**)realloc(lp,sizeof(named_string_t*)*(items+2)))==NULL)
728: break;
729: lp=np;
730: if((lp[items]=(named_string_t*)malloc(sizeof(named_string_t)))==NULL)
731: break;
732: if((lp[items]->name=strdup(name))==NULL)
733: break;
734: if((lp[items]->value=strdup(value))==NULL)
735: break;
736: items++;
737: }
738:
739: lp[items]=NULL; /* terminate list */
740:
741: return(lp);
742: }
743:
744: named_string_t**
745: iniGetNamedStringList(str_list_t* list, const char* section)
746: {
747: char* name;
748: char* value;
749: char str[INI_MAX_LINE_LEN];
750: ulong i,items=0;
751: named_string_t** lp;
752: named_string_t** np;
753:
754: if((lp=(named_string_t**)malloc(sizeof(named_string_t*)))==NULL)
755: return(NULL);
756:
757: *lp=NULL;
758:
759: if(list==NULL)
760: return(lp);
761:
762: for(i=find_section(*list,section);list[i]!=NULL;i++) {
763: SAFECOPY(str,list[i]);
764: if((name=key_name(str,&value))==NULL)
765: continue;
766: if(name==INI_NEW_SECTION)
767: break;
768: if((np=(named_string_t**)realloc(lp,sizeof(named_string_t*)*(items+2)))==NULL)
769: break;
770: lp=np;
771: if((lp[items]=(named_string_t*)malloc(sizeof(named_string_t)))==NULL)
772: break;
773: if((lp[items]->name=strdup(name))==NULL)
774: break;
775: if((lp[items]->value=strdup(value))==NULL)
776: break;
777: items++;
778: }
779:
780: lp[items]=NULL; /* terminate list */
781:
782: return(lp);
783: }
784:
785:
786: /* These functions read a single key of the specified type */
787:
788: long iniReadInteger(FILE* fp, const char* section, const char* key, long deflt)
789: {
790: char* value;
791: char buf[INI_MAX_VALUE_LEN];
792:
793: if((value=read_value(fp,section,key,buf))==NULL)
794: return(deflt);
795:
796: if(*value==0) /* blank value */
797: return(deflt);
798:
799: return(strtol(value,NULL,0));
800: }
801:
802: long iniGetInteger(str_list_t* list, const char* section, const char* key, long deflt)
803: {
804: char value[INI_MAX_VALUE_LEN];
805:
806: get_value(*list, section, key, value);
807:
808: if(*value==0) /* blank value */
809: return(deflt);
810:
811: return(strtol(value,NULL,0));
812: }
813:
814: ushort iniReadShortInt(FILE* fp, const char* section, const char* key, ushort deflt)
815: {
816: return((ushort)iniReadInteger(fp, section, key, deflt));
817: }
818:
819: ushort iniGetShortInt(str_list_t* list, const char* section, const char* key, ushort deflt)
820: {
821: return((ushort)iniGetInteger(list, section, key, deflt));
822: }
823:
824: #if !defined(NO_SOCKET_SUPPORT)
825:
826: static ulong parseIpAddress(const char* value)
827: {
828: if(strchr(value,'.')==NULL)
829: return(strtol(value,NULL,0));
830:
831: return(ntohl(inet_addr(value)));
832: }
833:
834: ulong iniReadIpAddress(FILE* fp, const char* section, const char* key, ulong deflt)
835: {
836: char buf[INI_MAX_VALUE_LEN];
837: char* value;
838:
839: if((value=read_value(fp,section,key,buf))==NULL)
840: return(deflt);
841:
842: if(*value==0) /* blank value */
843: return(deflt);
844:
845: return(parseIpAddress(value));
846: }
847:
848: ulong iniGetIpAddress(str_list_t* list, const char* section, const char* key, ulong deflt)
849: {
850: char value[INI_MAX_VALUE_LEN];
851:
852: get_value(*list, section, key, value);
853:
854: if(*value==0) /* blank value */
855: return(deflt);
856:
857: return(parseIpAddress(value));
858: }
859:
860: #endif /* !NO_SOCKET_SUPPORT */
861:
862: char* iniFileName(char* dest, size_t maxlen, const char* indir, const char* infname)
863: {
864: char dir[MAX_PATH+1];
865: char fname[MAX_PATH+1];
866: char ext[MAX_PATH+1];
867: char* p;
868:
869: SAFECOPY(dir,indir);
870: backslash(dir);
871: SAFECOPY(fname,infname);
872: ext[0]=0;
873: if((p=getfext(fname))!=NULL) {
874: SAFECOPY(ext,p);
875: *p=0;
876: }
877:
878: #if !defined(NO_SOCKET_SUPPORT)
879: {
880: char hostname[128];
881:
882: if(gethostname(hostname,sizeof(hostname))==0) {
883: safe_snprintf(dest,maxlen,"%s%s.%s%s",dir,fname,hostname,ext);
884: if(fexistcase(dest)) /* path/file.host.domain.ini */
885: return(dest);
886: if((p=strchr(hostname,'.'))!=NULL) {
887: *p=0;
888: safe_snprintf(dest,maxlen,"%s%s.%s%s",dir,fname,hostname,ext);
889: if(fexistcase(dest)) /* path/file.host.ini */
890: return(dest);
891: }
892: }
893: }
894: #endif
895:
896: safe_snprintf(dest,maxlen,"%s%s%s",dir,fname,ext);
897: fexistcase(dest); /* path/file.ini */
898: return(dest);
899: }
900:
901: double iniReadFloat(FILE* fp, const char* section, const char* key, double deflt)
902: {
903: char buf[INI_MAX_VALUE_LEN];
904: char* value;
905:
906: if((value=read_value(fp,section,key,buf))==NULL)
907: return(deflt);
908:
909: if(*value==0) /* blank value */
910: return(deflt);
911:
912: return(atof(value));
913: }
914:
915: double iniGetFloat(str_list_t* list, const char* section, const char* key, double deflt)
916: {
917: char value[INI_MAX_VALUE_LEN];
918:
919: get_value(*list, section, key, value);
920:
921: if(*value==0) /* blank value */
922: return(deflt);
923:
924: return(atof(value));
925: }
926:
927: static BOOL parseBool(const char* value)
928: {
929: if(!stricmp(value,"TRUE") || !stricmp(value,"YES"))
930: return(TRUE);
931:
932: return(INT_TO_BOOL(strtol(value,NULL,0)));
933: }
934:
935: BOOL iniReadBool(FILE* fp, const char* section, const char* key, BOOL deflt)
936: {
937: char buf[INI_MAX_VALUE_LEN];
938: char* value;
939:
940: if((value=read_value(fp,section,key,buf))==NULL)
941: return(deflt);
942:
943: if(*value==0) /* blank value */
944: return(deflt);
945:
946: return(parseBool(value));
947: }
948:
949: BOOL iniGetBool(str_list_t* list, const char* section, const char* key, BOOL deflt)
950: {
951: char value[INI_MAX_VALUE_LEN];
952:
953: get_value(*list, section, key, value);
954:
955: if(*value==0) /* blank value */
956: return(deflt);
957:
958: return(parseBool(value));
959: }
960:
961: static ulong parseBitField(char* value, ini_bitdesc_t* bitdesc)
962: {
963: int i;
964: char* p;
965: char* tp;
966: ulong v=0;
967:
968: for(p=value;*p;) {
969: tp=strchr(p,'|');
970: if(tp!=NULL)
971: *tp=0;
972: truncsp(p);
973:
974: for(i=0;bitdesc[i].name;i++)
975: if(!stricmp(bitdesc[i].name,p))
976: break;
977:
978: if(bitdesc[i].name)
979: v|=bitdesc[i].bit;
980: else
981: v|=strtoul(p,NULL,0);
982:
983: if(tp==NULL)
984: break;
985:
986: p=tp+1;
987: SKIP_WHITESPACE(p);
988: }
989:
990: return(v);
991: }
992:
993: ulong iniReadBitField(FILE* fp, const char* section, const char* key,
994: ini_bitdesc_t* bitdesc, ulong deflt)
995: {
996: char* value;
997: char buf[INI_MAX_VALUE_LEN];
998:
999: if((value=read_value(fp,section,key,buf))==NULL)
1000: return(deflt);
1001:
1002: return(parseBitField(value,bitdesc));
1003: }
1004:
1005: ulong iniGetBitField(str_list_t* list, const char* section, const char* key,
1006: ini_bitdesc_t* bitdesc, ulong deflt)
1007: {
1008: char value[INI_MAX_VALUE_LEN];
1009:
1010: get_value(*list, section, key, value);
1011:
1012: if(*value==0) /* blank value */
1013: return(deflt);
1014:
1015: return(parseBitField(value,bitdesc));
1016: }
1017:
1018: FILE* iniOpenFile(const char* fname)
1019: {
1020: char* mode="r+";
1021:
1022: if(!fexist(fname))
1023: mode="w+";
1024:
1025: return(fopen(fname,mode));
1026: }
1027:
1028: BOOL iniCloseFile(FILE* fp)
1029: {
1030: return(fclose(fp)==0);
1031: }
1032:
1033: str_list_t iniReadFile(FILE* fp)
1034: {
1035: size_t i;
1036: str_list_t list;
1037:
1038: rewind(fp);
1039:
1040: list = strListReadFile(fp, NULL, INI_MAX_LINE_LEN);
1041: if(list!=NULL) {
1042: /* truncate new-line chars off end of strings */
1043: for(i=0; list[i]!=NULL; i++)
1044: truncnl(list[i]);
1045: }
1046:
1047: return(list);
1048: }
1049:
1050: BOOL iniWriteFile(FILE* fp, const str_list_t list)
1051: {
1052: size_t count;
1053:
1054: rewind(fp);
1055:
1056: if(chsize(fileno(fp),0)!=0) /* truncate */
1057: return(FALSE);
1058:
1059: count = strListWriteFile(fp,list,"\n");
1060:
1061: return(count == strListCount(list));
1062: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.