Annotation of libaitcfg/src/queue.c, revision 1.1.1.1.2.1
1.1.1.1.2.1! misho 1: /*************************************************************************
! 2: * (C) 2008 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
! 3: * by Michael Pounov <misho@openbsd-bg.org>
! 4: *
! 5: * $Author: misho $
! 6: * $Id: global.h,v 4.0.2.3 2008/03/06 10:08:48 misho Exp $
! 7: *
! 8: *************************************************************************/
1.1 misho 9: #include "global.h"
10: #include "aitcfg.h"
11:
12:
13: /*
14: * SelectAttribute() Select item //{tagPair} from config list with attribute parameter(s)
15: * @cfg = Head list element
16: * @csSec = Config section //[{csSec}], if NULL search in *default* section
17: * @csAttr = Config attribute //{csAttr} = ..., if NULL search in *any* attribute
18: * return: NULL not found attribute; //{tagPair} selected first seen attribute item from list
19: */
20: static inline struct tagPair *SelectAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr)
21: {
22: struct tagPair *av;
23:
24: if (!cfg)
25: return NULL;
26:
27: for (av = cfg->slh_first; av; av = av->sle_next) {
28: if ((!csSec || !*csSec) && !av->psSection) {
29: if (!csAttr)
30: return av;
31: if (!strcmp((char*) av->psAttribute, (char*) csAttr))
32: return av;
33: }
34: if (csSec && av->psSection && !strcmp((char*) av->psSection, (char*) csSec)) {
35: if (!csAttr)
36: return av;
37: if (!strcmp((char*) av->psAttribute, (char*) csAttr))
38: return av;
39: }
40: }
41:
42: return NULL;
43: }
44:
45: /*
46: * DestroyAttribute() Free //{tagPair} item elements memory and destroy resource
47: * @pair = Free this element
48: */
49: static inline void DestroyAttribute(struct tagPair *pair)
50: {
51: if (!pair)
52: return;
53:
54: if (pair->psValue)
55: free(pair->psValue);
56: if (pair->psAttribute)
57: free(pair->psAttribute);
58: if (pair->psSection)
59: free(pair->psSection);
60:
61: free(pair);
62: }
63:
64: // ----------------------------------------------
65:
66: /*
67: * cfg_FindAttribute() Find attribute position in config list
68: * @cfg = Head list element
69: * @csSec = Config section //[{csSec}]
70: * @csAttr = Config attribute //{csAttr} = ...
71: * return: 0 not found item; -1 error: null parameters; >0 position in list
72: */
73: inline int cfg_FindAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr)
74: {
75: struct tagPair *av;
76: register int cx = 0;
77:
78: if (!cfg || !csAttr)
79: return -1;
80:
81: for (av = cfg->slh_first; av; av = av->sle_next) {
82: ++cx;
83: if ((!csSec || !*csSec) && !av->psSection)
84: if (!strcmp((char*) av->psAttribute, (char*) csAttr))
85: return cx;
86: if (csSec && av->psSection && !strcmp((char*) av->psSection, (char*) csSec))
87: if (!strcmp((char*) av->psAttribute, (char*) csAttr))
88: return cx;
89: }
90:
91: return 0;
92: }
93:
94: /*
95: * cfg_UnsetAttribute() Unset item from config list and free resources
96: * @cfg = Head list element
97: * @csSec = Config section //[{csSec}], if NULL unset in *default* section
98: * @csAttr = Config attribute //{csAttr} = ..., if NULL unset as *any* attribute
99: * return: 0 item not found, -1 error: null parameters; >0 position in list
100: */
101: int cfg_UnsetAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr)
102: {
103: struct tagPair *av, *curr;
104: register int cx = 0;
105:
106: if (!cfg || !csAttr)
107: return -1;
108:
109: av = SelectAttribute(cfg, csSec, csAttr);
110: if (!av)
111: return 0;
112:
113: // remove element
114: // remove element when is first!
115: if (cfg->slh_first == av) {
116: cfg->slh_first = cfg->slh_first->sle_next;
117:
118: DestroyAttribute(av);
119: return 1;
120: }
121: // remove element in other cases...
122: curr = cfg->slh_first;
123: while (curr->sle_next != av) {
124: ++cx;
125: curr = curr->sle_next;
126: }
127: curr->sle_next = curr->sle_next->sle_next;
128:
129: DestroyAttribute(av);
130: return cx;
131: }
132:
133: /*
134: * cfg_SetAttribute() Set item in config list or add new item if not exists
135: * @cfg = Head list element
136: * @csSec = Config section //[{csSec}], if NULL set in *default* section
137: * @csAttr = Config attribute //{csAttr} = ..., if NULL set as *any* attribute
138: * @csVal = Config value //... = {csVal} to setup
139: * return: 0 nothing changed, -1 error: not enough memory; 1 find and update item; 2 added new item
140: */
141: int cfg_SetAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr, const u_char *csVal)
142: {
143: struct tagPair *av, *section;
144:
145: if (!cfg || !csAttr)
146: return -1;
147:
148: av = SelectAttribute(cfg, csSec, csAttr);
149: if (!av) {
150: section = SelectAttribute(cfg, csSec, NULL);
151:
152: av = malloc(sizeof(struct tagPair));
153: if (!av) {
154: LOGERR;
155: return -1;
156: } else {
157: memset(av, 0, sizeof(struct tagPair));
158:
159: if (!section) {
160: // add new element
161: av->sle_next = cfg->slh_first;
162: cfg->slh_first = av;
163: } else {
164: // add new element in existing section
165: av->sle_next = section->sle_next;
166: section->sle_next = av;
167: }
168: }
169: // added section name to element
170: if (csSec && *csSec) {
171: av->psSection = malloc(strlen((char*) csSec) + 1);
172: if (!av->psSection) {
173: LOGERR;
174: free(av);
175: return -1;
176: } else {
177: memset(av->psSection, 0, strlen((char*) csSec) + 1);
178: strcpy((char*) av->psSection, (char*) csSec);
179: }
180: } else
181: av->psSection = NULL;
182:
183: // added attribute to element
184: av->psAttribute = malloc(strlen((char*) csAttr) + 1);
185: if (!av->psAttribute) {
186: LOGERR;
187: free(av->psSection);
188: free(av);
189: return -1;
190: } else {
191: memset(av->psAttribute, 0, strlen((char*) csAttr) + 1);
192: strcpy((char*) av->psAttribute, (char*) csAttr);
193: }
194: // added value to element
195: if (csVal && *csVal) {
196: av->psValue = malloc(strlen((char*) csVal) + 1);
197: if (!av->psValue) {
198: LOGERR;
199: free(av->psAttribute);
200: free(av->psSection);
201: free(av);
202: return -1;
203: } else {
204: memset(av->psValue, 0, strlen((char*) csVal) + 1);
205: strcpy((char*) av->psValue, (char*) csVal);
206: }
207: } else {
208: av->psValue = malloc(1);
209: *av->psValue = 0;
210: }
211:
212: // Added new element
213: return 2;
214: }
215:
216: if (strcmp((char*) csVal, (char*) av->psValue)) {
217: av->psValue = realloc(av->psValue, strlen((char*) csVal) + 1);
218: memset(av->psValue, 0, strlen((char*) csVal) + 1);
219: strcpy((char*) av->psValue, (char*) csVal);
220:
221: // Update element
222: return 1;
223: }
224:
225: // Nothing happens ... finded & values is equal!
226: return 0;
227: }
228:
229: /*
230: * cfg_GetAttribute() Get item from config list and return his value
231: * @cfg = Head list element
232: * @csSec = Config section //[{csSec}], if NULL unset in *default* section
233: * @csAttr = Config attribute //{csAttr} = ..., if NULL unset as *any* attribute
234: * return: NULL item not found or null parameters; !=NULL value const string
235: */
236: inline const u_char *cfg_GetAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr)
237: {
238: struct tagPair *av;
239:
240: if (!cfg || !csAttr)
241: return NULL;
242:
243: av = SelectAttribute(cfg, csSec, csAttr);
244: if (!av)
245: return NULL;
246:
247: return av->psValue;
248: }
249:
250: // --------------------------------------------------------------
251:
252: /*
253: * cfg_LoadAttribute() Extended get attribute, if not found item return *default value*
254: * @cfg = Head list element
255: * @csSec = Config section //[{csSec}], if NULL unset in *default* section
256: * @csAttr = Config attribute //{csAttr} = ..., if NULL unset as *any* attribute
257: * @psVal = Return buffer for item Value //... = {psVal}
258: * @ValLen = Length of buffer //{psVal} for return
259: * @csDefValue = *Default Value* for return in //{psVal}, if not found item in config list
260: * return: 0 item not found, -1 error: null parameters; >0 number of copied bytes in //{psVal}
261: */
262: int cfg_LoadAttribute(sl_config * __restrict cfg, const u_char *csSec, const u_char *csAttr,
263: u_char * __restrict psVal, int ValLen, const char *csDefValue)
264: {
265: struct tagPair *av;
266: int ret = 0;
267:
268: if (!cfg || !csAttr || !ValLen || !psVal)
269: return -1;
270:
271: memset(psVal, 0, ValLen);
272: av = SelectAttribute(cfg, csSec, csAttr);
273: if (!av) {
274: if (csDefValue) {
275: strncpy((char*) psVal, csDefValue, ValLen - 1);
276: ret = strlen((char*) psVal);
277: }
278:
279: return ret;
280: }
281:
282: if (!av->psValue || !*av->psValue) {
283: if (csDefValue) {
284: strncpy((char*) psVal, csDefValue, ValLen - 1);
285: ret = strlen((char*) psVal);
286: }
287: } else {
288: strncpy((char*) psVal, (char*) av->psValue, ValLen - 1);
289: ret = strlen((char*) psVal);
290: }
291:
292: return ret;
293: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>