gwenhywfar  4.99.15beta
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 
45 GWEN_INHERIT(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR)
46 
47 
48 
49 GWEN_CONFIGMGR *GWEN_ConfigMgrDir_Factory(GWEN_UNUSED GWEN_PLUGIN *pl, const char *url)
50 {
51  GWEN_CONFIGMGR *cfg;
52 
53  cfg=GWEN_ConfigMgrDir_new(url);
54  GWEN_ConfigMgr_SetGetGroupFn(cfg, GWEN_ConfigMgrDir_GetGroup);
55  GWEN_ConfigMgr_SetSetGroupFn(cfg, GWEN_ConfigMgrDir_SetGroup);
56  GWEN_ConfigMgr_SetHasGroupFn(cfg, GWEN_ConfigMgrDir_HasGroup);
57  GWEN_ConfigMgr_SetLockGroupFn(cfg, GWEN_ConfigMgrDir_LockGroup);
58  GWEN_ConfigMgr_SetUnlockGroupFn(cfg, GWEN_ConfigMgrDir_UnlockGroup);
59  GWEN_ConfigMgr_SetGetUniqueIdFn(cfg, GWEN_ConfigMgrDir_GetUniqueId);
60  GWEN_ConfigMgr_SetMkUniqueIdFromIdFn(cfg, GWEN_ConfigMgrDir_MkUniqueIdFromId);
61  GWEN_ConfigMgr_SetDeleteGroupFn(cfg, GWEN_ConfigMgrDir_DeleteGroup);
62  GWEN_ConfigMgr_SetListGroupsFn(cfg, GWEN_ConfigMgrDir_ListGroups);
63  GWEN_ConfigMgr_SetListSubGroupsFn(cfg, GWEN_ConfigMgrDir_ListSubGroups);
64 
65  return cfg;
66 }
67 
68 
69 
70 GWEN_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 
87 GWEN_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 
134 GWENHYWFAR_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 
164 int 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 
253 int 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 
342 void 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 
371 void 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 
406 GWEN_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 
430 int 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 
478 int 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 
530 int 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 
556  return 0;
557 }
558 
559 
560 
561 int GWEN_ConfigMgrDir_LockGroup(GWEN_CONFIGMGR *cfg,
562  const char *groupName,
563  const char *subGroupName)
564 {
565  GWEN_BUFFER *nbuf;
566  GWEN_CONFIGMGR_DIR *xcfg;
567  int rv;
568  GWEN_FSLOCK *lck;
569  GWEN_FSLOCK_RESULT res;
570 
571  assert(cfg);
572  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
573  assert(xcfg);
574 
575  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
576  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
577 
578  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
579  GWEN_PATH_FLAGS_CHECKROOT |
580  GWEN_PATH_FLAGS_VARIABLE);
581  if (rv<0) {
582  DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
583  GWEN_Buffer_GetStart(nbuf), rv);
584  GWEN_Buffer_free(nbuf);
585  return rv;
586  }
587 
588  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
589  if (lck) {
590  DBG_ERROR(GWEN_LOGDOMAIN,
591  "Group [%s/%s] is already locked",
592  groupName, subGroupName);
593  GWEN_Buffer_free(nbuf);
594  return GWEN_ERROR_LOCK;
595  }
596 
597  lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
598  res=GWEN_FSLock_Lock(lck, 60000, 0);
599  if (res!=GWEN_FSLock_ResultOk) {
600  DBG_ERROR(GWEN_LOGDOMAIN,
601  "Could not lock group [%s/%s]: %d",
602  groupName, subGroupName, res);
603  GWEN_FSLock_free(lck);
604  GWEN_Buffer_free(nbuf);
605  return GWEN_ERROR_LOCK;
606  }
607 
608  GWEN_FSLock_List_Add(lck, xcfg->fileLocks);
609  GWEN_Buffer_free(nbuf);
610  return 0;
611 }
612 
613 
614 
615 int GWEN_ConfigMgrDir_UnlockGroup(GWEN_CONFIGMGR *cfg,
616  const char *groupName,
617  const char *subGroupName)
618 {
619  GWEN_BUFFER *nbuf;
620  GWEN_CONFIGMGR_DIR *xcfg;
621  GWEN_FSLOCK *lck;
622  GWEN_FSLOCK_RESULT res;
623 
624  assert(cfg);
625  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
626  assert(xcfg);
627 
628  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
629  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
630 
631  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
632  if (lck==NULL) {
633  DBG_ERROR(GWEN_LOGDOMAIN,
634  "Group [%s/%s] is not locked",
635  groupName, subGroupName);
636  GWEN_Buffer_free(nbuf);
637  return GWEN_ERROR_LOCK;
638  }
639 
640  res=GWEN_FSLock_Unlock(lck);
641  if (res!=GWEN_FSLock_ResultOk) {
642  DBG_ERROR(GWEN_LOGDOMAIN,
643  "Could not unlock group [%s/%s]: %d",
644  groupName, subGroupName, res);
645  GWEN_FSLock_List_Del(lck);
646  GWEN_FSLock_free(lck);
647  GWEN_Buffer_free(nbuf);
648  return GWEN_ERROR_LOCK;
649  }
650 
651  GWEN_FSLock_List_Del(lck);
652  GWEN_FSLock_free(lck);
653  GWEN_Buffer_free(nbuf);
654 
655  return 0;
656 }
657 
658 
659 
660 int GWEN_ConfigMgrDir_GetUniqueId(GWEN_CONFIGMGR *cfg,
661  const char *groupName,
662  char *buffer,
663  uint32_t bufferLen)
664 {
665  GWEN_CONFIGMGR_DIR *xcfg;
666  int rv;
667  uint32_t uid;
668  char ubuf[64];
669 
670  assert(cfg);
671  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
672  assert(xcfg);
673 
674  rv=GWEN_ConfigMgrDir__GetUniqueId(cfg, groupName, &uid);
675  if (rv<0) {
676  DBG_INFO(GWEN_LOGDOMAIN, "Could not create unique id (%d)", rv);
677  return rv;
678  }
679  snprintf(ubuf, sizeof(ubuf)-1, "uid::%08x", uid);
680  ubuf[sizeof(ubuf)-1]=0;
681 
682  /* return new id */
683  strncpy(buffer, ubuf, bufferLen-1);
684  buffer[bufferLen-1]=0;
685 
686  return 0;
687 }
688 
689 
690 
691 int GWEN_ConfigMgrDir_MkUniqueIdFromId(GWEN_CONFIGMGR *cfg,
692  const char *groupName,
693  uint32_t uid,
694  int doCheck,
695  char *buffer,
696  uint32_t bufferLen)
697 {
698  GWEN_CONFIGMGR_DIR *xcfg;
699  int rv;
700  char ubuf[64];
701 
702  assert(cfg);
703  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
704  assert(xcfg);
705 
706  snprintf(ubuf, sizeof(ubuf)-1, "%08x", uid);
707  ubuf[sizeof(ubuf)-1]=0;
708 
709  if (doCheck) {
710  GWEN_BUFFER *nbuf;
711 
712  /* check whether that group already exists */
713  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
714  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, ubuf, nbuf);
715 
716  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
717  GWEN_PATH_FLAGS_CHECKROOT |
718  GWEN_PATH_FLAGS_NAMEMUSTEXIST |
719  GWEN_PATH_FLAGS_VARIABLE);
720  if (rv>=0) {
721  DBG_INFO(GWEN_LOGDOMAIN, "Path already exists [%s]: %d",
722  GWEN_Buffer_GetStart(nbuf), rv);
723  GWEN_Buffer_free(nbuf);
724  return rv;
725  }
726  GWEN_Buffer_free(nbuf);
727 
728  /* update lastId if necessary */
729  rv=GWEN_ConfigMgrDir__UpdateLastUniqueId(cfg, groupName, uid);
730  if (rv<0) {
731  DBG_INFO(GWEN_LOGDOMAIN, "Could not update unique id (%d)", rv);
732  return rv;
733  }
734  }
735 
736  /* return new id */
737  strncpy(buffer, ubuf, bufferLen-1);
738  buffer[bufferLen-1]=0;
739 
740  return 0;
741 }
742 
743 
744 
745 int GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg,
746  const char *groupName,
747  const char *subGroupName)
748 {
749  GWEN_BUFFER *nbuf;
750  GWEN_CONFIGMGR_DIR *xcfg;
751  int rv;
752  GWEN_FSLOCK *lck;
753  GWEN_FSLOCK_RESULT res;
754 
755  assert(cfg);
756  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
757  assert(xcfg);
758 
759  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
760  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
761 
762  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
763  GWEN_PATH_FLAGS_CHECKROOT |
764  GWEN_PATH_FLAGS_VARIABLE);
765  if (rv<0) {
766  DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
767  GWEN_Buffer_GetStart(nbuf), rv);
768  GWEN_Buffer_free(nbuf);
769  return rv;
770  }
771 
772  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
773  if (lck) {
774  DBG_ERROR(GWEN_LOGDOMAIN,
775  "Group [%s/%s] is still locked",
776  groupName, subGroupName);
777  GWEN_Buffer_free(nbuf);
778  return GWEN_ERROR_LOCK;
779  }
780 
781  lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
782  res=GWEN_FSLock_Lock(lck, 60000, 0);
783  if (res!=GWEN_FSLock_ResultOk) {
784  DBG_ERROR(GWEN_LOGDOMAIN,
785  "Could not lock group [%s/%s]: %d",
786  groupName, subGroupName, res);
787  GWEN_FSLock_free(lck);
788  GWEN_Buffer_free(nbuf);
789  return GWEN_ERROR_LOCK;
790  }
791 
792  unlink(GWEN_Buffer_GetStart(nbuf));
793 
794  GWEN_FSLock_Unlock(lck);
795  GWEN_FSLock_free(lck);
796  GWEN_Buffer_free(nbuf);
797 
798  return 0;
799 }
800 
801 
802 
803 int GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg,
804  GWEN_STRINGLIST *sl)
805 {
806  GWEN_CONFIGMGR_DIR *xcfg;
807  int rv;
808 
809  assert(cfg);
810  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
811  assert(xcfg);
812 
813  assert(xcfg->folder);
814 
815  rv=GWEN_Directory_GetDirEntries(xcfg->folder, sl, NULL);
816  if (rv<0) {
817  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
818  return rv;
819  }
820 
821  return 0;
822 }
823 
824 
825 
826 int GWEN_ConfigMgrDir_ListSubGroups(GWEN_CONFIGMGR *cfg,
827  const char *groupName,
828  GWEN_STRINGLIST *sl)
829 {
830  GWEN_BUFFER *nbuf;
831  GWEN_CONFIGMGR_DIR *xcfg;
832  int rv;
833  GWEN_STRINGLIST *rawsl;
834 
835  assert(cfg);
836  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
837  assert(xcfg);
838 
839  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
840  GWEN_ConfigMgrDir_AddGroupDirName(cfg, groupName, nbuf);
841 
842  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
843  GWEN_PATH_FLAGS_CHECKROOT |
844  GWEN_PATH_FLAGS_PATHMUSTEXIST |
845  GWEN_PATH_FLAGS_NAMEMUSTEXIST);
846  if (rv<0) {
847  DBG_INFO(GWEN_LOGDOMAIN, "Path not found (%d)", rv);
848  GWEN_Buffer_free(nbuf);
849  return 0;
850  }
851 
852  rawsl=GWEN_StringList_new();
853  rv=GWEN_Directory_GetFileEntries(GWEN_Buffer_GetStart(nbuf), rawsl, "*.conf");
854  if (rv<0) {
855  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
856  GWEN_StringList_free(rawsl);
857  GWEN_Buffer_free(nbuf);
858  return rv;
859  }
860  else {
861  GWEN_STRINGLISTENTRY *se;
862  GWEN_BUFFER *tbuf;
863 
864  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
865  se=GWEN_StringList_FirstEntry(rawsl);
866  while (se) {
867  char buffer[256];
868  char *p;
869 
870  strncpy(buffer, GWEN_StringListEntry_Data(se), sizeof(buffer)-1);
871  buffer[sizeof(buffer)-1]=0;
872  p=strrchr(buffer, '.');
873  if (p) {
874  *p=0;
875  GWEN_Text_UnescapeToBuffer(buffer, tbuf);
876  GWEN_StringList_AppendString(sl, GWEN_Buffer_GetStart(tbuf), 0, 1);
877  GWEN_Buffer_Reset(tbuf);
878  }
879 
880  se=GWEN_StringListEntry_Next(se);
881  }
882  GWEN_Buffer_free(tbuf);
883  GWEN_StringList_free(rawsl);
884  GWEN_Buffer_free(nbuf);
885  return 0;
886  }
887 }
888 
889 
890 
891 
892 
GWEN_ConfigMgrDir_DeleteGroup
int GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:745
GWEN_ConfigMgrDir_FindLock
GWEN_FSLOCK * GWEN_ConfigMgrDir_FindLock(GWEN_CONFIGMGR *cfg, const char *fname)
Definition: cfgdir.c:406
GWEN_Url_free
void GWEN_Url_free(GWEN_URL *st)
Definition: url.c:38
GWEN_CONFIGMGR
struct GWEN_CONFIGMGR GWEN_CONFIGMGR
Definition: configmgr.h:36
GWEN_FSLock_free
GWENHYWFAR_API void GWEN_FSLock_free(GWEN_FSLOCK *fl)
GWEN_PLUGIN_MANAGER
struct GWEN_PLUGIN_MANAGER GWEN_PLUGIN_MANAGER
Definition: plugin.h:40
GWEN_Buffer_GetStart
char * GWEN_Buffer_GetStart(const GWEN_BUFFER *bf)
Definition: buffer.c:235
GWEN_STRINGLISTENTRY
struct GWEN_STRINGLISTENTRYSTRUCT GWEN_STRINGLISTENTRY
Definition: stringlist.h:51
GWEN_DB_NODE
struct GWEN_DB_NODE GWEN_DB_NODE
Definition: db.h:228
GWEN_PLUGIN
struct GWEN_PLUGIN GWEN_PLUGIN
Definition: plugin.h:39
GWEN_DB_Group_free
void GWEN_DB_Group_free(GWEN_DB_NODE *n)
Definition: db.c:408
GWEN_ConfigMgrDir_FreeData
GWENHYWFAR_CB void GWEN_ConfigMgrDir_FreeData(GWEN_UNUSED void *bp, void *p)
Definition: cfgdir.c:134
GWEN_DIR_SEPARATOR_S
#define GWEN_DIR_SEPARATOR_S
Definition: gwenhywfarapi.h:103
GWEN_ConfigMgrDir_GetUniqueId
int GWEN_ConfigMgrDir_GetUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, char *buffer, uint32_t bufferLen)
Definition: cfgdir.c:660
GWEN_ConfigMgrDir_ListGroups
int GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg, GWEN_STRINGLIST *sl)
Definition: cfgdir.c:803
GWEN_ConfigMgr_SetDeleteGroupFn
GWEN_CONFIGMGR_DELETEGROUP_FN GWEN_ConfigMgr_SetDeleteGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_DELETEGROUP_FN f)
Definition: configmgr.c:245
GWEN_ConfigMgr_new
GWEN_CONFIGMGR * GWEN_ConfigMgr_new(const char *url)
Definition: configmgr.c:120
GWEN_ConfigMgrDir_AddGroupFileName
void GWEN_ConfigMgrDir_AddGroupFileName(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_BUFFER *nbuf)
Definition: cfgdir.c:371
GWEN_FREE_OBJECT
#define GWEN_FREE_OBJECT(varname)
Definition: memory.h:92
NULL
#define NULL
Definition: binreloc.c:297
GWEN_PATH_FLAGS_CREATE_GROUP
#define GWEN_PATH_FLAGS_CREATE_GROUP
Definition: path.h:96
GWEN_ConfigMgrDir_ListSubGroups
int GWEN_ConfigMgrDir_ListSubGroups(GWEN_CONFIGMGR *cfg, const char *groupName, GWEN_STRINGLIST *sl)
Definition: cfgdir.c:826
GWEN_FSLock_TypeFile
Definition: fslock.h:66
GWEN_ConfigMgr_SetGetGroupFn
GWEN_CONFIGMGR_GETGROUP_FN GWEN_ConfigMgr_SetGetGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_GETGROUP_FN f)
Definition: configmgr.c:146
DBG_WARN
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:123
GWEN_ConfigMgrDir_GetGroup
int GWEN_ConfigMgrDir_GetGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_DB_NODE **pDb)
Definition: cfgdir.c:430
GWEN_FSLock_List_free
void GWEN_FSLock_List_free(GWEN_FSLOCK_LIST *l)
GWEN_ConfigMgr_free
void GWEN_ConfigMgr_free(GWEN_CONFIGMGR *mgr)
Definition: configmgr.c:135
GWEN_ConfigMgrDir_AddGroupDirName
void GWEN_ConfigMgrDir_AddGroupDirName(GWEN_CONFIGMGR *cfg, const char *groupName, GWEN_BUFFER *nbuf)
Definition: cfgdir.c:342
GWEN_LOGDOMAIN
#define GWEN_LOGDOMAIN
Definition: logger.h:35
GWEN_FSLock_List_new
GWEN_FSLOCK_LIST * GWEN_FSLock_List_new()
GWEN_Buffer_GetPos
uint32_t GWEN_Buffer_GetPos(const GWEN_BUFFER *bf)
Definition: buffer.c:253
GWEN_Buffer_new
GWEN_BUFFER * GWEN_Buffer_new(char *buffer, uint32_t size, uint32_t used, int take)
Definition: buffer.c:38
GWEN_ConfigMgrDir_LockGroup
int GWEN_ConfigMgrDir_LockGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:561
GWEN_StringList_FirstEntry
GWEN_STRINGLISTENTRY * GWEN_StringList_FirstEntry(const GWEN_STRINGLIST *sl)
Definition: stringlist.c:366
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:719
GWEN_StringListEntry_Data
const char * GWEN_StringListEntry_Data(const GWEN_STRINGLISTENTRY *se)
Definition: stringlist.c:382
GWEN_ConfigMgrDir_new
GWEN_CONFIGMGR * GWEN_ConfigMgrDir_new(const char *url)
Definition: cfgdir.c:87
configmgr_dir_factory
GWEN_PLUGIN * configmgr_dir_factory(GWEN_PLUGIN_MANAGER *pm, const char *modName, const char *fileName)
Definition: cfgdir.c:70
GWEN_StringList_free
void GWEN_StringList_free(GWEN_STRINGLIST *sl)
Definition: stringlist.c:58
GWEN_ConfigMgrDir_Factory
GWEN_CONFIGMGR * GWEN_ConfigMgrDir_Factory(GWEN_UNUSED GWEN_PLUGIN *pl, const char *url)
Definition: cfgdir.c:49
GWEN_FSLock_List_First
GWEN_FSLOCK * GWEN_FSLock_List_First(const GWEN_FSLOCK_LIST *l)
GWEN_NEW_OBJECT
#define GWEN_NEW_OBJECT(typ, varname)
Definition: memory.h:86
GWEN_ConfigMgrDir_MkUniqueIdFromId
int GWEN_ConfigMgrDir_MkUniqueIdFromId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t uid, int doCheck, char *buffer, uint32_t bufferLen)
Definition: cfgdir.c:691
GWEN_FSLock_new
GWENHYWFAR_API GWEN_FSLOCK * GWEN_FSLock_new(const char *fname, GWEN_FSLOCK_TYPE t)
GWEN_StringList_AppendString
int GWEN_StringList_AppendString(GWEN_STRINGLIST *sl, const char *s, int take, int checkDouble)
Definition: stringlist.c:241
GWEN_URL
struct GWEN_URL GWEN_URL
Definition: url.h:77
GWENHYWFAR_CB
#define GWENHYWFAR_CB
Definition: gwenhywfarapi.h:89
GWEN_ConfigMgr_SetGetUniqueIdFn
GWEN_CONFIGMGR_GETUNIQUEID_FN GWEN_ConfigMgr_SetGetUniqueIdFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_GETUNIQUEID_FN f)
Definition: configmgr.c:217
GWEN_ConfigMgr_SetMkUniqueIdFromIdFn
GWEN_CONFIGMGR_MKUNIQUEIDFROMID_FN GWEN_ConfigMgr_SetMkUniqueIdFromIdFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_MKUNIQUEIDFROMID_FN f)
Definition: configmgr.c:231
GWEN_PATH_FLAGS_VARIABLE
#define GWEN_PATH_FLAGS_VARIABLE
Definition: path.h:111
GWEN_Text_EscapeToBuffer
int GWEN_Text_EscapeToBuffer(const char *src, GWEN_BUFFER *buf)
Definition: text.c:1349
GWEN_ConfigMgrDir__UpdateLastUniqueId
int GWEN_ConfigMgrDir__UpdateLastUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t uid)
Definition: cfgdir.c:253
GWEN_STRINGLIST
struct GWEN_STRINGLISTSTRUCT GWEN_STRINGLIST
Definition: stringlist.h:54
GWEN_ConfigMgr_SetUnlockGroupFn
GWEN_CONFIGMGR_UNLOCKGROUP_FN GWEN_ConfigMgr_SetUnlockGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_UNLOCKGROUP_FN f)
Definition: configmgr.c:203
GWEN_ConfigMgr_Plugin_SetFactoryFn
void GWEN_ConfigMgr_Plugin_SetFactoryFn(GWEN_PLUGIN *pl, GWEN_CONFIGMGR_PLUGIN_FACTORYFN f)
Definition: configmgr.c:454
GWEN_FSLOCK_RESULT
GWEN_FSLOCK_RESULT
Definition: fslock.h:71
GWEN_FSLock_Lock
GWENHYWFAR_API GWEN_FSLOCK_RESULT GWEN_FSLock_Lock(GWEN_FSLOCK *fl, int timeout, uint32_t gid)
GWEN_Directory_GetDirEntries
GWENHYWFAR_API int GWEN_Directory_GetDirEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition: directory_all.c:516
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:85
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:41
GWEN_Url_GetServer
const char * GWEN_Url_GetServer(const GWEN_URL *st)
Definition: url.c:184
GWEN_Text_UnescapeToBuffer
int GWEN_Text_UnescapeToBuffer(const char *src, GWEN_BUFFER *buf)
Definition: text.c:1384
GWEN_FSLock_List_Del
void GWEN_FSLock_List_Del(GWEN_FSLOCK *element)
GWEN_PATH_FLAGS_CHECKROOT
#define GWEN_PATH_FLAGS_CHECKROOT
Definition: path.h:142
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_ConfigMgrDir__GetUniqueId
int GWEN_ConfigMgrDir__GetUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t *pUniqueId)
Definition: cfgdir.c:164
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
GWEN_FSLock_List_Next
GWEN_FSLOCK * GWEN_FSLock_List_Next(const GWEN_FSLOCK *element)
GWEN_Url_fromString
GWEN_URL * GWEN_Url_fromString(const char *str)
Definition: urlfns.c:24
GWEN_FSLock_List_Add
void GWEN_FSLock_List_Add(GWEN_FSLOCK *element, GWEN_FSLOCK_LIST *list)
GWEN_ConfigMgrDir_UnlockGroup
int GWEN_ConfigMgrDir_UnlockGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:615
GWEN_StringListEntry_Next
GWEN_STRINGLISTENTRY * GWEN_StringListEntry_Next(const GWEN_STRINGLISTENTRY *se)
Definition: stringlist.c:374
GWEN_PATH_FLAGS_PATHMUSTEXIST
#define GWEN_PATH_FLAGS_PATHMUSTEXIST
Definition: path.h:66
GWEN_ConfigMgr_SetLockGroupFn
GWEN_CONFIGMGR_LOCKGROUP_FN GWEN_ConfigMgr_SetLockGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LOCKGROUP_FN f)
Definition: configmgr.c:189
DBG_INFO
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:177
GWEN_ERROR_LOCK
#define GWEN_ERROR_LOCK
Definition: error.h:131
GWEN_Directory_GetPath
GWENHYWFAR_API int GWEN_Directory_GetPath(const char *path, unsigned int flags)
Definition: directory_all.c:220
GWEN_ConfigMgr_SetListSubGroupsFn
GWEN_CONFIGMGR_LISTSUBGROUPS_FN GWEN_ConfigMgr_SetListSubGroupsFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LISTSUBGROUPS_FN f)
Definition: configmgr.c:273
GWEN_DB_ReadFile
GWENHYWFAR_API int GWEN_DB_ReadFile(GWEN_DB_NODE *n, const char *fname, uint32_t dbflags)
Definition: dbrw.c:1003
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_DB_Group_new
GWEN_DB_NODE * GWEN_DB_Group_new(const char *name)
Definition: db.c:160
GWEN_Directory_GetFileEntries
GWENHYWFAR_API int GWEN_Directory_GetFileEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition: directory_all.c:470
GWEN_ConfigMgr_SetSetGroupFn
GWEN_CONFIGMGR_SETGROUP_FN GWEN_ConfigMgr_SetSetGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_SETGROUP_FN f)
Definition: configmgr.c:160
GWEN_INHERIT
#define GWEN_INHERIT(bt, t)
Definition: inherit.h:264
GWEN_DB_WriteFile
GWENHYWFAR_API int GWEN_DB_WriteFile(GWEN_DB_NODE *n, const char *fname, uint32_t dbflags)
Definition: dbrw.c:535
GWEN_FSLock_ResultOk
Definition: fslock.h:72
GWEN_FSLock_Unlock
GWENHYWFAR_API GWEN_FSLOCK_RESULT GWEN_FSLock_Unlock(GWEN_FSLOCK *fl)
GWEN_ConfigMgr_SetListGroupsFn
GWEN_CONFIGMGR_LISTGROUPS_FN GWEN_ConfigMgr_SetListGroupsFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LISTGROUPS_FN f)
Definition: configmgr.c:259
GWEN_FSLock_List_GetCount
uint32_t GWEN_FSLock_List_GetCount(const GWEN_FSLOCK_LIST *l)
GWEN_ConfigMgrDir_SetGroup
int GWEN_ConfigMgrDir_SetGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_DB_NODE *db)
Definition: cfgdir.c:478
GWEN_INHERIT_SETDATA
#define GWEN_INHERIT_SETDATA(bt, t, element, data, fn)
Definition: inherit.h:292
GWEN_StringList_new
GWEN_STRINGLIST * GWEN_StringList_new(void)
Definition: stringlist.c:46
GWEN_ConfigMgr_SetHasGroupFn
GWEN_CONFIGMGR_HASGROUP_FN GWEN_ConfigMgr_SetHasGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_HASGROUP_FN f)
Definition: configmgr.c:174
GWEN_PATH_FLAGS_NAMEMUSTEXIST
#define GWEN_PATH_FLAGS_NAMEMUSTEXIST
Definition: path.h:84
GWEN_Url_GetPath
const char * GWEN_Url_GetPath(const GWEN_URL *st)
Definition: url.c:223
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:145
GWEN_ConfigMgrDir_HasGroup
int GWEN_ConfigMgrDir_HasGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:530
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:1062
GWEN_DB_FLAGS_DEFAULT
#define GWEN_DB_FLAGS_DEFAULT
Definition: db.h:168
GWEN_INHERIT_GETDATA
#define GWEN_INHERIT_GETDATA(bt, t, element)
Definition: inherit.h:271
GWEN_DB_FLAGS_ALLOW_EMPTY_STREAM
#define GWEN_DB_FLAGS_ALLOW_EMPTY_STREAM
Definition: db.h:119
Generated by   doxygen 1.8.15