gwenhywfar 5.14.1
cfgdir.c
Go to the documentation of this file.
1/***************************************************************************
2 begin : Sat Sep 27 2008
3 copyright : (C) 2008 by Martin Preuss
4 email : martin@libchipcard.de
5
6 ***************************************************************************
7 * *
8 * This library is free software; you can redistribute it and/or *
9 * modify it under the terms of the GNU Lesser General Public *
10 * License as published by the Free Software Foundation; either *
11 * version 2.1 of the License, or (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16 * Lesser General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU Lesser General Public *
19 * License along with this library; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 * *
23 ***************************************************************************/
24
25
26#ifdef HAVE_CONFIG_H
27# include <config.h>
28#endif
29
30#include "cfgdir_p.h"
31
32#include <gwenhywfar/debug.h>
33#include <gwenhywfar/misc.h>
34#include <gwenhywfar/text.h>
35#include <gwenhywfar/directory.h>
36#include <gwenhywfar/urlfns.h>
37
38#include <unistd.h>
39#include <errno.h>
40#include <string.h>
41#include <ctype.h>
42
43
44
45GWEN_INHERIT(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR)
46
47
48
67
68
69
70GWEN_PLUGIN *configmgr_dir_factory(GWEN_PLUGIN_MANAGER *pm,
71 const char *modName,
72 const char *fileName)
73{
74 GWEN_PLUGIN *pl;
75
76 pl=GWEN_ConfigMgr_Plugin_new(pm, modName, fileName);
77 assert(pl);
78
79 GWEN_ConfigMgr_Plugin_SetFactoryFn(pl, GWEN_ConfigMgrDir_Factory);
80
81 return pl;
82
83}
84
85
86
87GWEN_CONFIGMGR *GWEN_ConfigMgrDir_new(const char *url)
88{
89 GWEN_CONFIGMGR *cfg;
90 GWEN_CONFIGMGR_DIR *xcfg;
91 GWEN_URL *gurl;
92
93 cfg=GWEN_ConfigMgr_new(url);
94 GWEN_NEW_OBJECT(GWEN_CONFIGMGR_DIR, xcfg);
95 GWEN_INHERIT_SETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg, xcfg,
96 GWEN_ConfigMgrDir_FreeData);
97 xcfg->fileLocks=GWEN_FSLock_List_new();
98
99 gurl=GWEN_Url_fromString(url);
100 if (gurl) {
101 const char *s;
102 GWEN_BUFFER *nbuf;
103
104 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
105 s=GWEN_Url_GetServer(gurl);
106 if (s)
107 GWEN_Buffer_AppendString(nbuf, s);
108 s=GWEN_Url_GetPath(gurl);
109 if (s) {
110 /* Does this begin with a slash? If not, we add one, but only if
111 this isn't a drive letter (for windows!) */
112 if (*s!='/' && *s!='\\'
113 && !(isalpha(s[0]) && s[1] == ':'
114 && (s[2] == '/' || s[2] == '\\'))) {
115 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
116 }
117 GWEN_Buffer_AppendString(nbuf, s);
118 }
119 xcfg->folder=strdup(GWEN_Buffer_GetStart(nbuf));
120 GWEN_Url_free(gurl);
121 GWEN_Buffer_free(nbuf);
122 }
123 else {
124 DBG_ERROR(GWEN_LOGDOMAIN, "Bad URL [%s]", url);
125 GWEN_ConfigMgr_free(cfg);
126 return NULL;
127 }
128
129 return cfg;
130}
131
132
133
134GWENHYWFAR_CB void GWEN_ConfigMgrDir_FreeData(GWEN_UNUSED void *bp, void *p)
135{
136 GWEN_CONFIGMGR_DIR *xcfg;
137
138 xcfg=(GWEN_CONFIGMGR_DIR *) p;
139
140 if (GWEN_FSLock_List_GetCount(xcfg->fileLocks)) {
141 GWEN_FSLOCK *lck;
142
143 DBG_WARN(GWEN_LOGDOMAIN, "Some groups are still locked, unlocking");
144 lck=GWEN_FSLock_List_First(xcfg->fileLocks);
145 while (lck) {
146 GWEN_FSLOCK_RESULT res;
147
148 res=GWEN_FSLock_Unlock(lck);
149 if (res!=GWEN_FSLock_ResultOk) {
150 DBG_INFO(GWEN_LOGDOMAIN, "Unable to unlock file [%s]: %d",
151 GWEN_FSLock_GetName(lck), res);
152 }
153 lck=GWEN_FSLock_List_Next(lck);
154 }
155 }
156 GWEN_FSLock_List_free(xcfg->fileLocks);
157
158 free(xcfg->folder);
159 GWEN_FREE_OBJECT(xcfg);
160}
161
162
163
164int GWEN_ConfigMgrDir__GetUniqueId(GWEN_CONFIGMGR *cfg,
165 const char *groupName,
166 uint32_t *pUniqueId)
167{
168 GWEN_CONFIGMGR_DIR *xcfg;
169 GWEN_BUFFER *nbuf;
170 uint32_t uniqueId=0;
171 GWEN_FSLOCK *lck;
172 GWEN_FSLOCK_RESULT res;
173 FILE *f;
174 int rv;
175
176 assert(cfg);
177 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
178 assert(xcfg);
179
180 assert(xcfg->folder);
181 assert(groupName);
182
183 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
184 GWEN_Buffer_AppendString(nbuf, xcfg->folder);
185 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
186 GWEN_Text_EscapeToBuffer(groupName, nbuf);
187 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
188 GWEN_Buffer_AppendString(nbuf, "uniqueid");
189
190 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
191 GWEN_PATH_FLAGS_CHECKROOT |
192 GWEN_PATH_FLAGS_VARIABLE);
193 if (rv<0) {
194 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
195 return rv;
196 }
197
198 lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
199 res=GWEN_FSLock_Lock(lck, 60000, 0);
200 if (res!=GWEN_FSLock_ResultOk) {
201 DBG_ERROR(GWEN_LOGDOMAIN,
202 "Could not lock group [%s]: %d",
203 groupName, res);
204 GWEN_FSLock_free(lck);
205 GWEN_Buffer_free(nbuf);
206 return GWEN_ERROR_LOCK;
207 }
208
209 /* read last id */
210 f=fopen(GWEN_Buffer_GetStart(nbuf), "r");
211 if (f) {
212 int i;
213
214 if (1!=fscanf(f, "%d", &i))
215 i=0;
216 uniqueId=i;
217 fclose(f);
218 }
219
220 uniqueId++;
221
222 f=fopen(GWEN_Buffer_GetStart(nbuf), "w");
223 if (f==NULL) {
224 DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
225 GWEN_Buffer_GetStart(nbuf),
226 strerror(errno));
227 GWEN_FSLock_Unlock(lck);
228 GWEN_FSLock_free(lck);
229 GWEN_Buffer_free(nbuf);
230 return GWEN_ERROR_LOCK;
231 }
232 fprintf(f, "%d", (int)uniqueId);
233 if (fclose(f)) {
234 DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
235 GWEN_Buffer_GetStart(nbuf),
236 strerror(errno));
237 GWEN_FSLock_Unlock(lck);
238 GWEN_FSLock_free(lck);
239 GWEN_Buffer_free(nbuf);
240 return GWEN_ERROR_LOCK;
241 }
242
243 GWEN_FSLock_Unlock(lck);
244 GWEN_FSLock_free(lck);
245 GWEN_Buffer_free(nbuf);
246
247 *pUniqueId=uniqueId;
248 return 0;
249}
250
251
252
253int GWEN_ConfigMgrDir__UpdateLastUniqueId(GWEN_CONFIGMGR *cfg,
254 const char *groupName,
255 uint32_t uid)
256{
257 GWEN_CONFIGMGR_DIR *xcfg;
258 GWEN_BUFFER *nbuf;
259 uint32_t uniqueId=0;
260 GWEN_FSLOCK *lck;
261 GWEN_FSLOCK_RESULT res;
262 FILE *f;
263 int rv;
264
265 assert(cfg);
266 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
267 assert(xcfg);
268
269 assert(xcfg->folder);
270 assert(groupName);
271
272 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
273 GWEN_Buffer_AppendString(nbuf, xcfg->folder);
274 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
275 GWEN_Text_EscapeToBuffer(groupName, nbuf);
276 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
277 GWEN_Buffer_AppendString(nbuf, "uniqueid");
278
279 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
280 GWEN_PATH_FLAGS_CHECKROOT |
281 GWEN_PATH_FLAGS_VARIABLE);
282 if (rv<0) {
283 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
284 return rv;
285 }
286
287 lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
288 res=GWEN_FSLock_Lock(lck, 60000, 0);
289 if (res!=GWEN_FSLock_ResultOk) {
290 DBG_ERROR(GWEN_LOGDOMAIN,
291 "Could not lock group [%s]: %d",
292 groupName, res);
293 GWEN_FSLock_free(lck);
294 GWEN_Buffer_free(nbuf);
295 return GWEN_ERROR_LOCK;
296 }
297
298 /* read last id */
299 f=fopen(GWEN_Buffer_GetStart(nbuf), "r");
300 if (f) {
301 int i;
302
303 if (1!=fscanf(f, "%d", &i))
304 i=0;
305 uniqueId=i;
306 fclose(f);
307 }
308
309 if (uid>uniqueId) {
310 uniqueId=uid;
311
312 f=fopen(GWEN_Buffer_GetStart(nbuf), "w");
313 if (f==NULL) {
314 DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
315 GWEN_Buffer_GetStart(nbuf),
316 strerror(errno));
317 GWEN_FSLock_Unlock(lck);
318 GWEN_FSLock_free(lck);
319 GWEN_Buffer_free(nbuf);
320 return GWEN_ERROR_LOCK;
321 }
322 fprintf(f, "%d", (int)uniqueId);
323 if (fclose(f)) {
324 DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
325 GWEN_Buffer_GetStart(nbuf),
326 strerror(errno));
327 GWEN_FSLock_Unlock(lck);
328 GWEN_FSLock_free(lck);
329 GWEN_Buffer_free(nbuf);
330 return GWEN_ERROR_LOCK;
331 }
332 }
333 GWEN_FSLock_Unlock(lck);
334 GWEN_FSLock_free(lck);
335 GWEN_Buffer_free(nbuf);
336
337 return 0;
338}
339
340
341
342void GWEN_ConfigMgrDir_AddGroupDirName(GWEN_CONFIGMGR *cfg,
343 const char *groupName,
344 GWEN_BUFFER *nbuf)
345{
346 GWEN_CONFIGMGR_DIR *xcfg;
347 uint32_t pos;
348 char *p;
349
350 assert(cfg);
351 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
352 assert(xcfg);
353
354 assert(xcfg->folder);
355 assert(groupName);
356
357 GWEN_Buffer_AppendString(nbuf, xcfg->folder);
358 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
359 pos=GWEN_Buffer_GetPos(nbuf);
360 GWEN_Text_EscapeToBuffer(groupName, nbuf);
361 p=GWEN_Buffer_GetStart(nbuf)+pos;
362 while (*p) {
363 *p=tolower(*p);
364 p++;
365 }
366
367}
368
369
370
371void GWEN_ConfigMgrDir_AddGroupFileName(GWEN_CONFIGMGR *cfg,
372 const char *groupName,
373 const char *subGroupName,
374 GWEN_BUFFER *nbuf)
375{
376 GWEN_CONFIGMGR_DIR *xcfg;
377 uint32_t pos;
378 char *p;
379
380 assert(cfg);
381 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
382 assert(xcfg);
383
384 assert(xcfg->folder);
385 assert(groupName);
386 assert(subGroupName);
387
388 GWEN_Buffer_AppendString(nbuf, xcfg->folder);
389 pos=GWEN_Buffer_GetPos(nbuf);
390
391 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
392 GWEN_Text_EscapeToBuffer(groupName, nbuf);
393 GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
394 GWEN_Text_EscapeToBuffer(subGroupName, nbuf);
395 GWEN_Buffer_AppendString(nbuf, ".conf");
396
397 p=GWEN_Buffer_GetStart(nbuf)+pos;
398 while (*p) {
399 *p=tolower(*p);
400 p++;
401 }
402}
403
404
405
406GWEN_FSLOCK *GWEN_ConfigMgrDir_FindLock(GWEN_CONFIGMGR *cfg, const char *fname)
407{
408 GWEN_CONFIGMGR_DIR *xcfg;
409
410 assert(cfg);
411 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
412 assert(xcfg);
413
414 if (GWEN_FSLock_List_GetCount(xcfg->fileLocks)) {
415 GWEN_FSLOCK *lck;
416
417 lck=GWEN_FSLock_List_First(xcfg->fileLocks);
418 while (lck) {
419 if (strcasecmp(GWEN_FSLock_GetName(lck), fname)==0)
420 return lck;
421 lck=GWEN_FSLock_List_Next(lck);
422 }
423 }
424
425 return NULL;
426}
427
428
429
430int GWENHYWFAR_CB GWEN_ConfigMgrDir_GetGroup(GWEN_CONFIGMGR *cfg,
431 const char *groupName,
432 const char *subGroupName,
433 GWEN_DB_NODE **pDb)
434{
435 GWEN_BUFFER *nbuf;
436 GWEN_CONFIGMGR_DIR *xcfg;
437 int rv;
438 GWEN_DB_NODE *db;
439
440 assert(cfg);
441 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
442 assert(xcfg);
443
444 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
445 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
446
447 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
448 GWEN_PATH_FLAGS_CHECKROOT |
449 GWEN_PATH_FLAGS_VARIABLE);
450 if (rv<0) {
451 DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
452 GWEN_Buffer_GetStart(nbuf), rv);
453 GWEN_Buffer_free(nbuf);
454 return rv;
455 }
456
457 db=GWEN_DB_Group_new(subGroupName);
458 rv=GWEN_DB_ReadFile(db,
459 GWEN_Buffer_GetStart(nbuf),
460 GWEN_DB_FLAGS_DEFAULT |
461 GWEN_PATH_FLAGS_CREATE_GROUP |
462 GWEN_DB_FLAGS_ALLOW_EMPTY_STREAM);
463 if (rv<0) {
464 DBG_INFO(GWEN_LOGDOMAIN, "Could not read [%s]: %d",
465 GWEN_Buffer_GetStart(nbuf), rv);
466 GWEN_DB_Group_free(db);
467 GWEN_Buffer_free(nbuf);
468 return rv;
469 }
470
471 GWEN_Buffer_free(nbuf);
472 *pDb=db;
473 return 0;
474}
475
476
477
478int GWENHYWFAR_CB GWEN_ConfigMgrDir_SetGroup(GWEN_CONFIGMGR *cfg,
479 const char *groupName,
480 const char *subGroupName,
481 GWEN_DB_NODE *db)
482{
483 GWEN_BUFFER *nbuf;
484 GWEN_CONFIGMGR_DIR *xcfg;
485 int rv;
486 GWEN_FSLOCK *lck;
487
488 assert(cfg);
489 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
490 assert(xcfg);
491
492 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
493 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
494
495 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
496 GWEN_PATH_FLAGS_CHECKROOT |
497 GWEN_PATH_FLAGS_VARIABLE);
498 if (rv<0) {
499 DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
500 GWEN_Buffer_GetStart(nbuf), rv);
501 GWEN_Buffer_free(nbuf);
502 return rv;
503 }
504
505 lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
506 if (lck==NULL) {
507 DBG_ERROR(GWEN_LOGDOMAIN,
508 "Group [%s/%s] is not locked",
509 groupName, subGroupName);
510 GWEN_Buffer_free(nbuf);
511 return GWEN_ERROR_LOCK;
512 }
513
514 rv=GWEN_DB_WriteFile(db,
515 GWEN_Buffer_GetStart(nbuf),
516 GWEN_DB_FLAGS_DEFAULT);
517 if (rv<0) {
518 DBG_INFO(GWEN_LOGDOMAIN, "Could not write [%s]: %d",
519 GWEN_Buffer_GetStart(nbuf), rv);
520 GWEN_Buffer_free(nbuf);
521 return rv;
522 }
523
524 GWEN_Buffer_free(nbuf);
525 return 0;
526}
527
528
529
530int GWENHYWFAR_CB GWEN_ConfigMgrDir_HasGroup(GWEN_CONFIGMGR *cfg,
531 const char *groupName,
532 const char *subGroupName)
533{
534 GWEN_BUFFER *nbuf;
535 GWEN_CONFIGMGR_DIR *xcfg;
536 int rv;
537
538 assert(cfg);
539 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
540 assert(xcfg);
541
542 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
543 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
544
545 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
546 GWEN_PATH_FLAGS_CHECKROOT |
547 GWEN_PATH_FLAGS_NAMEMUSTEXIST |
548 GWEN_PATH_FLAGS_VARIABLE);
549 if (rv<0) {
550 DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
551 GWEN_Buffer_GetStart(nbuf), rv);
552 GWEN_Buffer_free(nbuf);
553 return rv;
554 }
555 GWEN_Buffer_free(nbuf);
556
557 return 0;
558}
559
560
561
562int GWENHYWFAR_CB GWEN_ConfigMgrDir_LockGroup(GWEN_CONFIGMGR *cfg,
563 const char *groupName,
564 const char *subGroupName)
565{
566 GWEN_BUFFER *nbuf;
567 GWEN_CONFIGMGR_DIR *xcfg;
568 int rv;
569 GWEN_FSLOCK *lck;
570 GWEN_FSLOCK_RESULT res;
571
572 assert(cfg);
573 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
574 assert(xcfg);
575
576 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
577 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
578
579 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
580 GWEN_PATH_FLAGS_CHECKROOT |
581 GWEN_PATH_FLAGS_VARIABLE);
582 if (rv<0) {
583 DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
584 GWEN_Buffer_GetStart(nbuf), rv);
585 GWEN_Buffer_free(nbuf);
586 return rv;
587 }
588
589 lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
590 if (lck) {
591 DBG_ERROR(GWEN_LOGDOMAIN,
592 "Group [%s/%s] is already locked",
593 groupName, subGroupName);
594 GWEN_Buffer_free(nbuf);
595 return GWEN_ERROR_LOCK;
596 }
597
598 lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
599 res=GWEN_FSLock_Lock(lck, 60000, 0);
600 if (res!=GWEN_FSLock_ResultOk) {
601 DBG_ERROR(GWEN_LOGDOMAIN,
602 "Could not lock group [%s/%s]: %d",
603 groupName, subGroupName, res);
604 GWEN_FSLock_free(lck);
605 GWEN_Buffer_free(nbuf);
606 return GWEN_ERROR_LOCK;
607 }
608
609 GWEN_FSLock_List_Add(lck, xcfg->fileLocks);
610 GWEN_Buffer_free(nbuf);
611 return 0;
612}
613
614
615
616int GWENHYWFAR_CB GWEN_ConfigMgrDir_UnlockGroup(GWEN_CONFIGMGR *cfg,
617 const char *groupName,
618 const char *subGroupName)
619{
620 GWEN_BUFFER *nbuf;
621 GWEN_CONFIGMGR_DIR *xcfg;
622 GWEN_FSLOCK *lck;
623 GWEN_FSLOCK_RESULT res;
624
625 assert(cfg);
626 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
627 assert(xcfg);
628
629 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
630 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
631
632 lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
633 if (lck==NULL) {
634 DBG_ERROR(GWEN_LOGDOMAIN,
635 "Group [%s/%s] is not locked",
636 groupName, subGroupName);
637 GWEN_Buffer_free(nbuf);
638 return GWEN_ERROR_LOCK;
639 }
640
641 res=GWEN_FSLock_Unlock(lck);
642 if (res!=GWEN_FSLock_ResultOk) {
643 DBG_ERROR(GWEN_LOGDOMAIN,
644 "Could not unlock group [%s/%s]: %d",
645 groupName, subGroupName, res);
646 GWEN_FSLock_List_Del(lck);
647 GWEN_FSLock_free(lck);
648 GWEN_Buffer_free(nbuf);
649 return GWEN_ERROR_LOCK;
650 }
651
652 GWEN_FSLock_List_Del(lck);
653 GWEN_FSLock_free(lck);
654 GWEN_Buffer_free(nbuf);
655
656 return 0;
657}
658
659
660
661int GWENHYWFAR_CB GWEN_ConfigMgrDir_GetUniqueId(GWEN_CONFIGMGR *cfg,
662 const char *groupName,
663 char *buffer,
664 uint32_t bufferLen)
665{
666 GWEN_CONFIGMGR_DIR *xcfg;
667 int rv;
668 uint32_t uid;
669 char ubuf[64];
670
671 assert(cfg);
672 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
673 assert(xcfg);
674
675 rv=GWEN_ConfigMgrDir__GetUniqueId(cfg, groupName, &uid);
676 if (rv<0) {
677 DBG_INFO(GWEN_LOGDOMAIN, "Could not create unique id (%d)", rv);
678 return rv;
679 }
680 snprintf(ubuf, sizeof(ubuf)-1, "uid::%08x", uid);
681 ubuf[sizeof(ubuf)-1]=0;
682
683 /* return new id */
684 strncpy(buffer, ubuf, bufferLen-1);
685 buffer[bufferLen-1]=0;
686
687 return 0;
688}
689
690
691
692int GWENHYWFAR_CB GWEN_ConfigMgrDir_MkUniqueIdFromId(GWEN_CONFIGMGR *cfg,
693 const char *groupName,
694 uint32_t uid,
695 int doCheck,
696 char *buffer,
697 uint32_t bufferLen)
698{
699 GWEN_CONFIGMGR_DIR *xcfg;
700 int rv;
701 char ubuf[64];
702
703 assert(cfg);
704 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
705 assert(xcfg);
706
707 rv=snprintf(ubuf, sizeof(ubuf)-1, "%08x", uid);
708 if (rv>=sizeof(ubuf)-1) {
709 DBG_ERROR(GWEN_LOGDOMAIN, "Id longer than %d (%d)? SNH!", (int)(sizeof(ubuf)-1), rv);
710 return GWEN_ERROR_INTERNAL;
711 }
712 else if (rv<0) {
713 DBG_ERROR(GWEN_LOGDOMAIN, "Error on snprintf: %d", rv);
714 return GWEN_ERROR_INTERNAL;
715 }
716 ubuf[rv]=0;
717
718 if (doCheck) {
719 GWEN_BUFFER *nbuf;
720
721 /* check whether that group already exists */
722 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
723 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, ubuf, nbuf);
724
725 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
726 GWEN_PATH_FLAGS_CHECKROOT |
727 GWEN_PATH_FLAGS_NAMEMUSTEXIST |
728 GWEN_PATH_FLAGS_VARIABLE);
729 if (rv>=0) {
730 DBG_INFO(GWEN_LOGDOMAIN, "Path already exists [%s]: %d",
731 GWEN_Buffer_GetStart(nbuf), rv);
732 GWEN_Buffer_free(nbuf);
733 return rv;
734 }
735 GWEN_Buffer_free(nbuf);
736
737 /* update lastId if necessary */
738 rv=GWEN_ConfigMgrDir__UpdateLastUniqueId(cfg, groupName, uid);
739 if (rv<0) {
740 DBG_INFO(GWEN_LOGDOMAIN, "Could not update unique id (%d)", rv);
741 return rv;
742 }
743 }
744
745 /* return new id */
746 strncpy(buffer, ubuf, bufferLen-1);
747 buffer[bufferLen-1]=0;
748
749 return 0;
750}
751
752
753
754int GWENHYWFAR_CB GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg,
755 const char *groupName,
756 const char *subGroupName)
757{
758 GWEN_BUFFER *nbuf;
759 GWEN_CONFIGMGR_DIR *xcfg;
760 int rv;
761 GWEN_FSLOCK *lck;
762 GWEN_FSLOCK_RESULT res;
763
764 assert(cfg);
765 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
766 assert(xcfg);
767
768 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
769 GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
770
771 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
772 GWEN_PATH_FLAGS_CHECKROOT |
773 GWEN_PATH_FLAGS_VARIABLE);
774 if (rv<0) {
775 DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
776 GWEN_Buffer_GetStart(nbuf), rv);
777 GWEN_Buffer_free(nbuf);
778 return rv;
779 }
780
781 lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
782 if (lck) {
783 DBG_ERROR(GWEN_LOGDOMAIN,
784 "Group [%s/%s] is still locked",
785 groupName, subGroupName);
786 GWEN_Buffer_free(nbuf);
787 return GWEN_ERROR_LOCK;
788 }
789
790 lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
791 res=GWEN_FSLock_Lock(lck, 60000, 0);
792 if (res!=GWEN_FSLock_ResultOk) {
793 DBG_ERROR(GWEN_LOGDOMAIN,
794 "Could not lock group [%s/%s]: %d",
795 groupName, subGroupName, res);
796 GWEN_FSLock_free(lck);
797 GWEN_Buffer_free(nbuf);
798 return GWEN_ERROR_LOCK;
799 }
800
801 unlink(GWEN_Buffer_GetStart(nbuf));
802
803 GWEN_FSLock_Unlock(lck);
804 GWEN_FSLock_free(lck);
805 GWEN_Buffer_free(nbuf);
806
807 return 0;
808}
809
810
811
812int GWENHYWFAR_CB GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg,
813 GWEN_STRINGLIST *sl)
814{
815 GWEN_CONFIGMGR_DIR *xcfg;
816 int rv;
817
818 assert(cfg);
819 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
820 assert(xcfg);
821
822 assert(xcfg->folder);
823
824 rv=GWEN_Directory_GetDirEntries(xcfg->folder, sl, NULL);
825 if (rv<0) {
826 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
827 return rv;
828 }
829
830 return 0;
831}
832
833
834
835int GWENHYWFAR_CB GWEN_ConfigMgrDir_ListSubGroups(GWEN_CONFIGMGR *cfg,
836 const char *groupName,
837 GWEN_STRINGLIST *sl)
838{
839 GWEN_BUFFER *nbuf;
840 GWEN_CONFIGMGR_DIR *xcfg;
841 int rv;
842 GWEN_STRINGLIST *rawsl;
843
844 assert(cfg);
845 xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
846 assert(xcfg);
847
848 nbuf=GWEN_Buffer_new(0, 256, 0, 1);
849 GWEN_ConfigMgrDir_AddGroupDirName(cfg, groupName, nbuf);
850
851 rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
852 GWEN_PATH_FLAGS_CHECKROOT |
853 GWEN_PATH_FLAGS_PATHMUSTEXIST |
854 GWEN_PATH_FLAGS_NAMEMUSTEXIST);
855 if (rv<0) {
856 DBG_INFO(GWEN_LOGDOMAIN, "Path not found (%d)", rv);
857 GWEN_Buffer_free(nbuf);
858 return 0;
859 }
860
861 rawsl=GWEN_StringList_new();
862 rv=GWEN_Directory_GetFileEntries(GWEN_Buffer_GetStart(nbuf), rawsl, "*.conf");
863 if (rv<0) {
864 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
865 GWEN_StringList_free(rawsl);
866 GWEN_Buffer_free(nbuf);
867 return rv;
868 }
869 else {
870 GWEN_STRINGLISTENTRY *se;
871 GWEN_BUFFER *tbuf;
872
873 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
874 se=GWEN_StringList_FirstEntry(rawsl);
875 while (se) {
876 char buffer[256];
877 char *p;
878
879 strncpy(buffer, GWEN_StringListEntry_Data(se), sizeof(buffer)-1);
880 buffer[sizeof(buffer)-1]=0;
881 p=strrchr(buffer, '.');
882 if (p) {
883 *p=0;
884 GWEN_Text_UnescapeToBuffer(buffer, tbuf);
885 GWEN_StringList_AppendString(sl, GWEN_Buffer_GetStart(tbuf), 0, 1);
886 GWEN_Buffer_Reset(tbuf);
887 }
888
889 se=GWEN_StringListEntry_Next(se);
890 }
891 GWEN_Buffer_free(tbuf);
892 GWEN_StringList_free(rawsl);
893 GWEN_Buffer_free(nbuf);
894 return 0;
895 }
896}
897
898
899
900
901
NULL
#define NULL
Definition binreloc.c:300
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition buffer.c:42
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition buffer.c:653
GWEN_Buffer_GetPos
uint32_t GWEN_Buffer_GetPos(const GWEN_BUFFER *bf)
Definition buffer.c:253
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition buffer.c:89
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition buffer.c:992
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition buffer.c:235
GWEN_ConfigMgrDir_ListGroups
int GWENHYWFAR_CB GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg, GWEN_STRINGLIST *sl)
Definition cfgdir.c:812
GWEN_ConfigMgrDir_FreeData
GWENHYWFAR_CB void GWEN_ConfigMgrDir_FreeData(GWEN_UNUSED void *bp, void *p)
Definition cfgdir.c:134
GWEN_ConfigMgrDir_GetUniqueId
int GWENHYWFAR_CB GWEN_ConfigMgrDir_GetUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, char *buffer, uint32_t bufferLen)
Definition cfgdir.c:661
GWEN_ConfigMgrDir__UpdateLastUniqueId
int GWEN_ConfigMgrDir__UpdateLastUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t uid)
Definition cfgdir.c:253
GWEN_ConfigMgrDir_new
GWEN_CONFIGMGR * GWEN_ConfigMgrDir_new(const char *url)
Definition cfgdir.c:87
GWEN_ConfigMgrDir_HasGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_HasGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition cfgdir.c:530
GWEN_ConfigMgrDir_GetGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_GetGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_DB_NODE **pDb)
Definition cfgdir.c:430
GWEN_ConfigMgrDir_AddGroupFileName
void GWEN_ConfigMgrDir_AddGroupFileName(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_BUFFER *nbuf)
Definition cfgdir.c:371
GWEN_ConfigMgrDir_FindLock
GWEN_FSLOCK * GWEN_ConfigMgrDir_FindLock(GWEN_CONFIGMGR *cfg, const char *fname)
Definition cfgdir.c:406
GWEN_ConfigMgrDir_DeleteGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition cfgdir.c:754
GWEN_ConfigMgrDir_LockGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_LockGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition cfgdir.c:562
GWEN_ConfigMgrDir__GetUniqueId
int GWEN_ConfigMgrDir__GetUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t *pUniqueId)
Definition cfgdir.c:164
configmgr_dir_factory
GWEN_PLUGIN * configmgr_dir_factory(GWEN_PLUGIN_MANAGER *pm, const char *modName, const char *fileName)
Definition cfgdir.c:70
GWEN_ConfigMgrDir_AddGroupDirName
void GWEN_ConfigMgrDir_AddGroupDirName(GWEN_CONFIGMGR *cfg, const char *groupName, GWEN_BUFFER *nbuf)
Definition cfgdir.c:342
GWEN_ConfigMgrDir_SetGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_SetGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_DB_NODE *db)
Definition cfgdir.c:478
GWEN_ConfigMgrDir_MkUniqueIdFromId
int GWENHYWFAR_CB GWEN_ConfigMgrDir_MkUniqueIdFromId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t uid, int doCheck, char *buffer, uint32_t bufferLen)
Definition cfgdir.c:692
GWEN_ConfigMgrDir_ListSubGroups
int GWENHYWFAR_CB GWEN_ConfigMgrDir_ListSubGroups(GWEN_CONFIGMGR *cfg, const char *groupName, GWEN_STRINGLIST *sl)
Definition cfgdir.c:835
GWEN_ConfigMgrDir_UnlockGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_UnlockGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition cfgdir.c:616
GWEN_ConfigMgrDir_Factory
GWEN_CONFIGMGR * GWEN_ConfigMgrDir_Factory(GWEN_UNUSED GWEN_PLUGIN *pl, const char *url)
Definition cfgdir.c:49
GWEN_ConfigMgr_SetUnlockGroupFn
GWEN_CONFIGMGR_UNLOCKGROUP_FN GWEN_ConfigMgr_SetUnlockGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_UNLOCKGROUP_FN f)
Definition configmgr.c:203
GWEN_ConfigMgr_SetDeleteGroupFn
GWEN_CONFIGMGR_DELETEGROUP_FN GWEN_ConfigMgr_SetDeleteGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_DELETEGROUP_FN f)
Definition configmgr.c:245
GWEN_ConfigMgr_free
void GWEN_ConfigMgr_free(GWEN_CONFIGMGR *mgr)
Definition configmgr.c:135
GWEN_ConfigMgr_SetHasGroupFn
GWEN_CONFIGMGR_HASGROUP_FN GWEN_ConfigMgr_SetHasGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_HASGROUP_FN f)
Definition configmgr.c:174
GWEN_ConfigMgr_SetGetGroupFn
GWEN_CONFIGMGR_GETGROUP_FN GWEN_ConfigMgr_SetGetGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_GETGROUP_FN f)
Definition configmgr.c:146
GWEN_ConfigMgr_SetLockGroupFn
GWEN_CONFIGMGR_LOCKGROUP_FN GWEN_ConfigMgr_SetLockGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LOCKGROUP_FN f)
Definition configmgr.c:189
GWEN_ConfigMgr_SetListGroupsFn
GWEN_CONFIGMGR_LISTGROUPS_FN GWEN_ConfigMgr_SetListGroupsFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LISTGROUPS_FN f)
Definition configmgr.c:259
GWEN_ConfigMgr_SetSetGroupFn
GWEN_CONFIGMGR_SETGROUP_FN GWEN_ConfigMgr_SetSetGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_SETGROUP_FN f)
Definition configmgr.c:160
GWEN_ConfigMgr_SetMkUniqueIdFromIdFn
GWEN_CONFIGMGR_MKUNIQUEIDFROMID_FN GWEN_ConfigMgr_SetMkUniqueIdFromIdFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_MKUNIQUEIDFROMID_FN f)
Definition configmgr.c:231
GWEN_ConfigMgr_SetGetUniqueIdFn
GWEN_CONFIGMGR_GETUNIQUEID_FN GWEN_ConfigMgr_SetGetUniqueIdFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_GETUNIQUEID_FN f)
Definition configmgr.c:217
GWEN_ConfigMgr_Plugin_new
GWEN_PLUGIN * GWEN_ConfigMgr_Plugin_new(GWEN_PLUGIN_MANAGER *pm, const char *name, const char *fileName)
Definition configmgr.c:427
GWEN_ConfigMgr_new
GWEN_CONFIGMGR * GWEN_ConfigMgr_new(const char *url)
Definition configmgr.c:120
GWEN_ConfigMgr_Plugin_SetFactoryFn
void GWEN_ConfigMgr_Plugin_SetFactoryFn(GWEN_PLUGIN *pl, GWEN_CONFIGMGR_PLUGIN_FACTORYFN f)
Definition configmgr.c:454
GWEN_ConfigMgr_SetListSubGroupsFn
GWEN_CONFIGMGR_LISTSUBGROUPS_FN GWEN_ConfigMgr_SetListSubGroupsFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LISTSUBGROUPS_FN f)
Definition configmgr.c:273
GWEN_CONFIGMGR
struct GWEN_CONFIGMGR GWEN_CONFIGMGR
Definition configmgr.h:36
GWEN_DB_Group_new
GWEN_DB_NODE * GWEN_DB_Group_new(const char *name)
Definition db.c:173
GWEN_DB_Group_free
void GWEN_DB_Group_free(GWEN_DB_NODE *n)
Definition db.c:421
GWEN_DB_ReadFile
GWENHYWFAR_API int GWEN_DB_ReadFile(GWEN_DB_NODE *n, const char *fname, uint32_t dbflags)
Definition dbrw.c:1003
GWEN_DB_WriteFile
GWENHYWFAR_API int GWEN_DB_WriteFile(GWEN_DB_NODE *n, const char *fname, uint32_t dbflags)
Definition dbrw.c:535
GWEN_DB_FLAGS_DEFAULT
#define GWEN_DB_FLAGS_DEFAULT
Definition db.h:168
GWEN_DB_NODE
struct GWEN_DB_NODE GWEN_DB_NODE
Definition db.h:228
GWEN_DB_FLAGS_ALLOW_EMPTY_STREAM
#define GWEN_DB_FLAGS_ALLOW_EMPTY_STREAM
Definition db.h:119
DBG_INFO
#define DBG_INFO(dbg_logger, format,...)
Definition debug.h:181
DBG_ERROR
#define DBG_ERROR(dbg_logger, format,...)
Definition debug.h:97
DBG_WARN
#define DBG_WARN(dbg_logger, format,...)
Definition debug.h:125
GWEN_Directory_GetDirEntries
GWENHYWFAR_API int GWEN_Directory_GetDirEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition directory_all.c:536
GWEN_Directory_GetFileEntries
GWENHYWFAR_API int GWEN_Directory_GetFileEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition directory_all.c:490
GWEN_Directory_GetPath
GWENHYWFAR_API int GWEN_Directory_GetPath(const char *path, unsigned int flags)
Definition directory_all.c:237
GWEN_ERROR_INTERNAL
#define GWEN_ERROR_INTERNAL
Definition error.h:125
GWEN_ERROR_LOCK
#define GWEN_ERROR_LOCK
Definition error.h:131
GWEN_FSLock_free
GWENHYWFAR_API void GWEN_FSLock_free(GWEN_FSLOCK *fl)
GWEN_FSLock_GetName
GWENHYWFAR_API const char * GWEN_FSLock_GetName(const GWEN_FSLOCK *fl)
GWEN_FSLOCK
struct GWEN_FSLOCK GWEN_FSLOCK
Definition fslock.h:59
GWEN_FSLock_new
GWENHYWFAR_API GWEN_FSLOCK * GWEN_FSLock_new(const char *fname, GWEN_FSLOCK_TYPE t)
GWEN_FSLOCK_RESULT
GWEN_FSLOCK_RESULT
Definition fslock.h:71
GWEN_FSLock_ResultOk
@ GWEN_FSLock_ResultOk
Definition fslock.h:72
GWEN_FSLock_Lock
GWENHYWFAR_API GWEN_FSLOCK_RESULT GWEN_FSLock_Lock(GWEN_FSLOCK *fl, int timeout, uint32_t gid)
GWEN_FSLock_TypeFile
@ GWEN_FSLock_TypeFile
Definition fslock.h:66
GWEN_FSLock_Unlock
GWENHYWFAR_API GWEN_FSLOCK_RESULT GWEN_FSLock_Unlock(GWEN_FSLOCK *fl)
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition buffer.h:38
GWEN_UNUSED
#define GWEN_UNUSED
Definition gwenhywfarapi.h:82
GWEN_DIR_SEPARATOR_S
#define GWEN_DIR_SEPARATOR_S
Definition gwenhywfarapi.h:108
GWENHYWFAR_CB
#define GWENHYWFAR_CB
Definition gwenhywfarapi.h:89
GWEN_INHERIT_SETDATA
#define GWEN_INHERIT_SETDATA(bt, t, element, data, fn)
Definition inherit.h:300
GWEN_INHERIT
#define GWEN_INHERIT(bt, t)
Definition inherit.h:264
GWEN_INHERIT_GETDATA
#define GWEN_INHERIT_GETDATA(bt, t, element)
Definition inherit.h:279
GWEN_FSLock_List_new
GWEN_FSLOCK_LIST * GWEN_FSLock_List_new()
GWEN_FSLock_List_GetCount
uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_LIST *l)
GWEN_FSLock_List_free
void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l)
GWEN_FSLock_List_First
GWEN_FSLOCK * GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l)
GWEN_FSLock_List_Next
GWEN_FSLOCK * GWEN_FSLock_List_Next(const GWEN_FSLOCK *element)
GWEN_FSLock_List_Add
void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list)
GWEN_FSLock_List_Del
void GWEN_FSLock_List_Del(GWEN_FSLOCK *element)
GWEN_LOGDOMAIN
#define GWEN_LOGDOMAIN
Definition logger.h:32
GWEN_FREE_OBJECT
#define GWEN_FREE_OBJECT(varname)
Definition memory.h:61
GWEN_NEW_OBJECT
#define GWEN_NEW_OBJECT(typ, varname)
Definition memory.h:55
GWEN_PATH_FLAGS_CHECKROOT
#define GWEN_PATH_FLAGS_CHECKROOT
Definition path.h:142
GWEN_PATH_FLAGS_CREATE_GROUP
#define GWEN_PATH_FLAGS_CREATE_GROUP
Definition path.h:96
GWEN_PATH_FLAGS_PATHMUSTEXIST
#define GWEN_PATH_FLAGS_PATHMUSTEXIST
Definition path.h:66
GWEN_PATH_FLAGS_VARIABLE
#define GWEN_PATH_FLAGS_VARIABLE
Definition path.h:111
GWEN_PATH_FLAGS_NAMEMUSTEXIST
#define GWEN_PATH_FLAGS_NAMEMUSTEXIST
Definition path.h:84
GWEN_PLUGIN_MANAGER
struct GWEN_PLUGIN_MANAGER GWEN_PLUGIN_MANAGER
Definition plugin.h:37
GWEN_PLUGIN
struct GWEN_PLUGIN GWEN_PLUGIN
Definition plugin.h:36
GWEN_StringList_free
void GWEN_StringList_free(GWEN_STRINGLIST *sl)
Definition stringlist.c:62
GWEN_StringListEntry_Data
const char * GWEN_StringListEntry_Data(const GWEN_STRINGLISTENTRY *se)
Definition stringlist.c:406
GWEN_StringListEntry_Next
GWEN_STRINGLISTENTRY * GWEN_StringListEntry_Next(const GWEN_STRINGLISTENTRY *se)
Definition stringlist.c:398
GWEN_StringList_AppendString
int GWEN_StringList_AppendString(GWEN_STRINGLIST *sl, const char *s, int take, int checkDouble)
Definition stringlist.c:245
GWEN_StringList_FirstEntry
GWEN_STRINGLISTENTRY * GWEN_StringList_FirstEntry(const GWEN_STRINGLIST *sl)
Definition stringlist.c:390
GWEN_StringList_new
GWEN_STRINGLIST * GWEN_StringList_new(void)
Definition stringlist.c:50
GWEN_STRINGLISTENTRY
struct GWEN_STRINGLISTENTRYSTRUCT GWEN_STRINGLISTENTRY
Definition stringlist.h:53
GWEN_STRINGLIST
struct GWEN_STRINGLISTSTRUCT GWEN_STRINGLIST
Definition stringlist.h:56
GWEN_Text_EscapeToBuffer
int GWEN_Text_EscapeToBuffer(const char *src, GWEN_BUFFER *buf)
Definition text.c:1376
GWEN_Text_UnescapeToBuffer
int GWEN_Text_UnescapeToBuffer(const char *src, GWEN_BUFFER *buf)
Definition text.c:1411
GWEN_Url_free
void GWEN_Url_free(GWEN_URL *st)
Definition url.c:40
GWEN_Url_GetPath
const char * GWEN_Url_GetPath(const GWEN_URL *st)
Definition url.c:225
GWEN_Url_GetServer
const char * GWEN_Url_GetServer(const GWEN_URL *st)
Definition url.c:186
GWEN_URL
struct GWEN_URL GWEN_URL
Definition url.h:77
GWEN_Url_fromString
GWEN_URL * GWEN_Url_fromString(const char *str)
Definition urlfns.c:24
Generated by doxygen 1.15.0