gwenhywfar  4.99.8beta
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  GWEN_CONFIGMGR *cfg;
51 
52  cfg=GWEN_ConfigMgrDir_new(url);
53  GWEN_ConfigMgr_SetGetGroupFn(cfg, GWEN_ConfigMgrDir_GetGroup);
54  GWEN_ConfigMgr_SetSetGroupFn(cfg, GWEN_ConfigMgrDir_SetGroup);
55  GWEN_ConfigMgr_SetLockGroupFn(cfg, GWEN_ConfigMgrDir_LockGroup);
56  GWEN_ConfigMgr_SetUnlockGroupFn(cfg, GWEN_ConfigMgrDir_UnlockGroup);
57  GWEN_ConfigMgr_SetGetUniqueIdFn(cfg, GWEN_ConfigMgrDir_GetUniqueId);
58  GWEN_ConfigMgr_SetMkUniqueIdFromIdFn(cfg, GWEN_ConfigMgrDir_MkUniqueIdFromId);
59  GWEN_ConfigMgr_SetDeleteGroupFn(cfg, GWEN_ConfigMgrDir_DeleteGroup);
60  GWEN_ConfigMgr_SetListGroupsFn(cfg, GWEN_ConfigMgrDir_ListGroups);
61  GWEN_ConfigMgr_SetListSubGroupsFn(cfg, GWEN_ConfigMgrDir_ListSubGroups);
62 
63  return cfg;
64 }
65 
66 
67 
68 GWEN_PLUGIN *configmgr_dir_factory(GWEN_PLUGIN_MANAGER *pm,
69  const char *modName,
70  const char *fileName) {
71  GWEN_PLUGIN *pl;
72 
73  pl=GWEN_ConfigMgr_Plugin_new(pm, modName, fileName);
74  assert(pl);
75 
76  GWEN_ConfigMgr_Plugin_SetFactoryFn(pl, GWEN_ConfigMgrDir_Factory);
77 
78  return pl;
79 
80 }
81 
82 
83 
84 GWEN_CONFIGMGR *GWEN_ConfigMgrDir_new(const char *url) {
85  GWEN_CONFIGMGR *cfg;
86  GWEN_CONFIGMGR_DIR *xcfg;
87  GWEN_URL *gurl;
88 
89  cfg=GWEN_ConfigMgr_new(url);
90  GWEN_NEW_OBJECT(GWEN_CONFIGMGR_DIR, xcfg);
91  GWEN_INHERIT_SETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg, xcfg,
92  GWEN_ConfigMgrDir_FreeData);
93  xcfg->fileLocks=GWEN_FSLock_List_new();
94 
95  gurl=GWEN_Url_fromString(url);
96  if (gurl) {
97  const char *s;
98  GWEN_BUFFER *nbuf;
99 
100  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
101  s=GWEN_Url_GetServer(gurl);
102  if (s)
103  GWEN_Buffer_AppendString(nbuf, s);
104  s=GWEN_Url_GetPath(gurl);
105  if (s) {
106  /* Does this begin with a slash? If not, we add one, but only if
107  this isn't a drive letter (for windows!) */
108  if (*s!='/' && *s!='\\'
109  && !(isalpha(s[0]) && s[1] == ':'
110  && (s[2] == '/' || s[2] == '\\'))) {
111  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
112  }
113  GWEN_Buffer_AppendString(nbuf, s);
114  }
115  xcfg->folder=strdup(GWEN_Buffer_GetStart(nbuf));
116  GWEN_Url_free(gurl);
117  GWEN_Buffer_free(nbuf);
118  }
119  else {
120  DBG_ERROR(GWEN_LOGDOMAIN, "Bad URL [%s]", url);
121  GWEN_ConfigMgr_free(cfg);
122  return NULL;
123  }
124 
125  return cfg;
126 }
127 
128 
129 
130 GWENHYWFAR_CB void GWEN_ConfigMgrDir_FreeData(GWEN_UNUSED void *bp, void *p) {
131  GWEN_CONFIGMGR_DIR *xcfg;
132 
133  xcfg=(GWEN_CONFIGMGR_DIR*) p;
134 
135  if (GWEN_FSLock_List_GetCount(xcfg->fileLocks)) {
136  GWEN_FSLOCK *lck;
137 
138  DBG_WARN(GWEN_LOGDOMAIN, "Some groups are still locked, unlocking");
139  lck=GWEN_FSLock_List_First(xcfg->fileLocks);
140  while(lck) {
141  GWEN_FSLOCK_RESULT res;
142 
143  res=GWEN_FSLock_Unlock(lck);
144  if (res!=GWEN_FSLock_ResultOk) {
145  DBG_INFO(GWEN_LOGDOMAIN, "Unable to unlock file [%s]: %d",
146  GWEN_FSLock_GetName(lck), res);
147  }
148  lck=GWEN_FSLock_List_Next(lck);
149  }
150  }
151  GWEN_FSLock_List_free(xcfg->fileLocks);
152 
153  free(xcfg->folder);
154  GWEN_FREE_OBJECT(xcfg);
155 }
156 
157 
158 
159 int GWEN_ConfigMgrDir__GetUniqueId(GWEN_CONFIGMGR *cfg,
160  const char *groupName,
161  uint32_t *pUniqueId){
162  GWEN_CONFIGMGR_DIR *xcfg;
163  GWEN_BUFFER *nbuf;
164  uint32_t uniqueId=0;
165  GWEN_FSLOCK *lck;
166  GWEN_FSLOCK_RESULT res;
167  FILE *f;
168  int rv;
169 
170  assert(cfg);
171  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
172  assert(xcfg);
173 
174  assert(xcfg->folder);
175  assert(groupName);
176 
177  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
178  GWEN_Buffer_AppendString(nbuf, xcfg->folder);
179  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
180  GWEN_Text_EscapeToBuffer(groupName, nbuf);
181  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
182  GWEN_Buffer_AppendString(nbuf, "uniqueid");
183 
184  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
185  GWEN_PATH_FLAGS_CHECKROOT |
186  GWEN_PATH_FLAGS_VARIABLE);
187  if (rv<0) {
188  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
189  return rv;
190  }
191 
192  lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
193  res=GWEN_FSLock_Lock(lck, 60000, 0);
194  if (res!=GWEN_FSLock_ResultOk) {
195  DBG_ERROR(GWEN_LOGDOMAIN,
196  "Could not lock group [%s]: %d",
197  groupName, res);
198  GWEN_FSLock_free(lck);
199  GWEN_Buffer_free(nbuf);
200  return GWEN_ERROR_LOCK;
201  }
202 
203  /* read last id */
204  f=fopen(GWEN_Buffer_GetStart(nbuf), "r");
205  if (f) {
206  int i;
207 
208  if (1!=fscanf(f, "%d", &i))
209  i=0;
210  uniqueId=i;
211  fclose(f);
212  }
213 
214  uniqueId++;
215 
216  f=fopen(GWEN_Buffer_GetStart(nbuf), "w");
217  if (f==NULL) {
218  DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
219  GWEN_Buffer_GetStart(nbuf),
220  strerror(errno));
221  GWEN_FSLock_Unlock(lck);
222  GWEN_FSLock_free(lck);
223  GWEN_Buffer_free(nbuf);
224  return GWEN_ERROR_LOCK;
225  }
226  fprintf(f, "%d", (int)uniqueId);
227  if (fclose(f)) {
228  DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
229  GWEN_Buffer_GetStart(nbuf),
230  strerror(errno));
231  GWEN_FSLock_Unlock(lck);
232  GWEN_FSLock_free(lck);
233  GWEN_Buffer_free(nbuf);
234  return GWEN_ERROR_LOCK;
235  }
236 
237  GWEN_FSLock_Unlock(lck);
238  GWEN_FSLock_free(lck);
239  GWEN_Buffer_free(nbuf);
240 
241  *pUniqueId=uniqueId;
242  return 0;
243 }
244 
245 
246 
247 int GWEN_ConfigMgrDir__UpdateLastUniqueId(GWEN_CONFIGMGR *cfg,
248  const char *groupName,
249  uint32_t uid){
250  GWEN_CONFIGMGR_DIR *xcfg;
251  GWEN_BUFFER *nbuf;
252  uint32_t uniqueId=0;
253  GWEN_FSLOCK *lck;
254  GWEN_FSLOCK_RESULT res;
255  FILE *f;
256  int rv;
257 
258  assert(cfg);
259  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
260  assert(xcfg);
261 
262  assert(xcfg->folder);
263  assert(groupName);
264 
265  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
266  GWEN_Buffer_AppendString(nbuf, xcfg->folder);
267  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
268  GWEN_Text_EscapeToBuffer(groupName, nbuf);
269  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
270  GWEN_Buffer_AppendString(nbuf, "uniqueid");
271 
272  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
273  GWEN_PATH_FLAGS_CHECKROOT |
274  GWEN_PATH_FLAGS_VARIABLE);
275  if (rv<0) {
276  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
277  return rv;
278  }
279 
280  lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
281  res=GWEN_FSLock_Lock(lck, 60000, 0);
282  if (res!=GWEN_FSLock_ResultOk) {
283  DBG_ERROR(GWEN_LOGDOMAIN,
284  "Could not lock group [%s]: %d",
285  groupName, res);
286  GWEN_FSLock_free(lck);
287  GWEN_Buffer_free(nbuf);
288  return GWEN_ERROR_LOCK;
289  }
290 
291  /* read last id */
292  f=fopen(GWEN_Buffer_GetStart(nbuf), "r");
293  if (f) {
294  int i;
295 
296  if (1!=fscanf(f, "%d", &i))
297  i=0;
298  uniqueId=i;
299  fclose(f);
300  }
301 
302  if (uid>uniqueId) {
303  uniqueId=uid;
304 
305  f=fopen(GWEN_Buffer_GetStart(nbuf), "w");
306  if (f==NULL) {
307  DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
308  GWEN_Buffer_GetStart(nbuf),
309  strerror(errno));
310  GWEN_FSLock_Unlock(lck);
311  GWEN_FSLock_free(lck);
312  GWEN_Buffer_free(nbuf);
313  return GWEN_ERROR_LOCK;
314  }
315  fprintf(f, "%d", (int)uniqueId);
316  if (fclose(f)) {
317  DBG_ERROR(GWEN_LOGDOMAIN, "fopen(%s, \"w\"): %s",
318  GWEN_Buffer_GetStart(nbuf),
319  strerror(errno));
320  GWEN_FSLock_Unlock(lck);
321  GWEN_FSLock_free(lck);
322  GWEN_Buffer_free(nbuf);
323  return GWEN_ERROR_LOCK;
324  }
325  }
326  GWEN_FSLock_Unlock(lck);
327  GWEN_FSLock_free(lck);
328  GWEN_Buffer_free(nbuf);
329 
330  return 0;
331 }
332 
333 
334 
335 void GWEN_ConfigMgrDir_AddGroupDirName(GWEN_CONFIGMGR *cfg,
336  const char *groupName,
337  GWEN_BUFFER *nbuf) {
338  GWEN_CONFIGMGR_DIR *xcfg;
339  uint32_t pos;
340  char *p;
341 
342  assert(cfg);
343  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
344  assert(xcfg);
345 
346  assert(xcfg->folder);
347  assert(groupName);
348 
349  GWEN_Buffer_AppendString(nbuf, xcfg->folder);
350  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
351  pos=GWEN_Buffer_GetPos(nbuf);
352  GWEN_Text_EscapeToBuffer(groupName, nbuf);
353  p=GWEN_Buffer_GetStart(nbuf)+pos;
354  while(*p) {
355  *p=tolower(*p);
356  p++;
357  }
358 
359 }
360 
361 
362 
363 void GWEN_ConfigMgrDir_AddGroupFileName(GWEN_CONFIGMGR *cfg,
364  const char *groupName,
365  const char *subGroupName,
366  GWEN_BUFFER *nbuf) {
367  GWEN_CONFIGMGR_DIR *xcfg;
368  uint32_t pos;
369  char *p;
370 
371  assert(cfg);
372  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
373  assert(xcfg);
374 
375  assert(xcfg->folder);
376  assert(groupName);
377  assert(subGroupName);
378 
379  GWEN_Buffer_AppendString(nbuf, xcfg->folder);
380  pos=GWEN_Buffer_GetPos(nbuf);
381 
382  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
383  GWEN_Text_EscapeToBuffer(groupName, nbuf);
384  GWEN_Buffer_AppendString(nbuf, GWEN_DIR_SEPARATOR_S);
385  GWEN_Text_EscapeToBuffer(subGroupName, nbuf);
386  GWEN_Buffer_AppendString(nbuf, ".conf");
387 
388  p=GWEN_Buffer_GetStart(nbuf)+pos;
389  while(*p) {
390  *p=tolower(*p);
391  p++;
392  }
393 }
394 
395 
396 
397 GWEN_FSLOCK *GWEN_ConfigMgrDir_FindLock(GWEN_CONFIGMGR *cfg, const char *fname) {
398  GWEN_CONFIGMGR_DIR *xcfg;
399 
400  assert(cfg);
401  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
402  assert(xcfg);
403 
404  if (GWEN_FSLock_List_GetCount(xcfg->fileLocks)) {
405  GWEN_FSLOCK *lck;
406 
407  lck=GWEN_FSLock_List_First(xcfg->fileLocks);
408  while(lck) {
409  if (strcasecmp(GWEN_FSLock_GetName(lck), fname)==0)
410  return lck;
411  lck=GWEN_FSLock_List_Next(lck);
412  }
413  }
414 
415  return NULL;
416 }
417 
418 
419 
420 int GWEN_ConfigMgrDir_GetGroup(GWEN_CONFIGMGR *cfg,
421  const char *groupName,
422  const char *subGroupName,
423  GWEN_DB_NODE **pDb) {
424  GWEN_BUFFER *nbuf;
425  GWEN_CONFIGMGR_DIR *xcfg;
426  int rv;
427  GWEN_DB_NODE *db;
428 
429  assert(cfg);
430  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
431  assert(xcfg);
432 
433  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
434  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
435 
436  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
437  GWEN_PATH_FLAGS_CHECKROOT |
438  GWEN_PATH_FLAGS_VARIABLE);
439  if (rv<0) {
440  DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
441  GWEN_Buffer_GetStart(nbuf), rv);
442  GWEN_Buffer_free(nbuf);
443  return rv;
444  }
445 
446  db=GWEN_DB_Group_new(subGroupName);
447  rv=GWEN_DB_ReadFile(db,
448  GWEN_Buffer_GetStart(nbuf),
449  GWEN_DB_FLAGS_DEFAULT |
450  GWEN_PATH_FLAGS_CREATE_GROUP |
451  GWEN_DB_FLAGS_ALLOW_EMPTY_STREAM);
452  if (rv<0) {
453  DBG_INFO(GWEN_LOGDOMAIN, "Could not read [%s]: %d",
454  GWEN_Buffer_GetStart(nbuf), rv);
455  GWEN_DB_Group_free(db);
456  GWEN_Buffer_free(nbuf);
457  return rv;
458  }
459 
460  GWEN_Buffer_free(nbuf);
461  *pDb=db;
462  return 0;
463 }
464 
465 
466 
467 int GWEN_ConfigMgrDir_SetGroup(GWEN_CONFIGMGR *cfg,
468  const char *groupName,
469  const char *subGroupName,
470  GWEN_DB_NODE *db) {
471  GWEN_BUFFER *nbuf;
472  GWEN_CONFIGMGR_DIR *xcfg;
473  int rv;
474  GWEN_FSLOCK *lck;
475 
476  assert(cfg);
477  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
478  assert(xcfg);
479 
480  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
481  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
482 
483  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
484  GWEN_PATH_FLAGS_CHECKROOT |
485  GWEN_PATH_FLAGS_VARIABLE);
486  if (rv<0) {
487  DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
488  GWEN_Buffer_GetStart(nbuf), rv);
489  GWEN_Buffer_free(nbuf);
490  return rv;
491  }
492 
493  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
494  if (lck==NULL) {
495  DBG_ERROR(GWEN_LOGDOMAIN,
496  "Group [%s/%s] is not locked",
497  groupName, subGroupName);
498  GWEN_Buffer_free(nbuf);
499  return GWEN_ERROR_LOCK;
500  }
501 
502  rv=GWEN_DB_WriteFile(db,
503  GWEN_Buffer_GetStart(nbuf),
504  GWEN_DB_FLAGS_DEFAULT);
505  if (rv<0) {
506  DBG_INFO(GWEN_LOGDOMAIN, "Could not write [%s]: %d",
507  GWEN_Buffer_GetStart(nbuf), rv);
508  GWEN_Buffer_free(nbuf);
509  return rv;
510  }
511 
512  GWEN_Buffer_free(nbuf);
513  return 0;
514 }
515 
516 
517 
518 int GWEN_ConfigMgrDir_LockGroup(GWEN_CONFIGMGR *cfg,
519  const char *groupName,
520  const char *subGroupName) {
521  GWEN_BUFFER *nbuf;
522  GWEN_CONFIGMGR_DIR *xcfg;
523  int rv;
524  GWEN_FSLOCK *lck;
525  GWEN_FSLOCK_RESULT res;
526 
527  assert(cfg);
528  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
529  assert(xcfg);
530 
531  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
532  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
533 
534  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
535  GWEN_PATH_FLAGS_CHECKROOT |
536  GWEN_PATH_FLAGS_VARIABLE);
537  if (rv<0) {
538  DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
539  GWEN_Buffer_GetStart(nbuf), rv);
540  GWEN_Buffer_free(nbuf);
541  return rv;
542  }
543 
544  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
545  if (lck) {
546  DBG_ERROR(GWEN_LOGDOMAIN,
547  "Group [%s/%s] is already locked",
548  groupName, subGroupName);
549  GWEN_Buffer_free(nbuf);
550  return GWEN_ERROR_LOCK;
551  }
552 
553  lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
554  res=GWEN_FSLock_Lock(lck, 60000, 0);
555  if (res!=GWEN_FSLock_ResultOk) {
556  DBG_ERROR(GWEN_LOGDOMAIN,
557  "Could not lock group [%s/%s]: %d",
558  groupName, subGroupName, res);
559  GWEN_FSLock_free(lck);
560  GWEN_Buffer_free(nbuf);
561  return GWEN_ERROR_LOCK;
562  }
563 
564  GWEN_FSLock_List_Add(lck, xcfg->fileLocks);
565  GWEN_Buffer_free(nbuf);
566  return 0;
567 }
568 
569 
570 
571 int GWEN_ConfigMgrDir_UnlockGroup(GWEN_CONFIGMGR *cfg,
572  const char *groupName,
573  const char *subGroupName) {
574  GWEN_BUFFER *nbuf;
575  GWEN_CONFIGMGR_DIR *xcfg;
576  GWEN_FSLOCK *lck;
577  GWEN_FSLOCK_RESULT res;
578 
579  assert(cfg);
580  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
581  assert(xcfg);
582 
583  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
584  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
585 
586  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
587  if (lck==NULL) {
588  DBG_ERROR(GWEN_LOGDOMAIN,
589  "Group [%s/%s] is not locked",
590  groupName, subGroupName);
591  GWEN_Buffer_free(nbuf);
592  return GWEN_ERROR_LOCK;
593  }
594 
595  res=GWEN_FSLock_Unlock(lck);
596  if (res!=GWEN_FSLock_ResultOk) {
597  DBG_ERROR(GWEN_LOGDOMAIN,
598  "Could not unlock group [%s/%s]: %d",
599  groupName, subGroupName, res);
600  GWEN_FSLock_List_Del(lck);
601  GWEN_FSLock_free(lck);
602  GWEN_Buffer_free(nbuf);
603  return GWEN_ERROR_LOCK;
604  }
605 
606  GWEN_FSLock_List_Del(lck);
607  GWEN_FSLock_free(lck);
608  GWEN_Buffer_free(nbuf);
609 
610  return 0;
611 }
612 
613 
614 
615 int GWEN_ConfigMgrDir_GetUniqueId(GWEN_CONFIGMGR *cfg,
616  const char *groupName,
617  char *buffer,
618  uint32_t bufferLen) {
619  GWEN_CONFIGMGR_DIR *xcfg;
620  int rv;
621  uint32_t uid;
622  char ubuf[64];
623 
624  assert(cfg);
625  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
626  assert(xcfg);
627 
628  rv=GWEN_ConfigMgrDir__GetUniqueId(cfg, groupName, &uid);
629  if (rv<0) {
630  DBG_INFO(GWEN_LOGDOMAIN, "Could not create unique id (%d)", rv);
631  return rv;
632  }
633  snprintf(ubuf, sizeof(ubuf)-1, "uid::%08x", uid);
634  ubuf[sizeof(ubuf)-1]=0;
635 
636  /* return new id */
637  strncpy(buffer, ubuf, bufferLen-1);
638  buffer[bufferLen-1]=0;
639 
640  return 0;
641 }
642 
643 
644 
645 int GWEN_ConfigMgrDir_MkUniqueIdFromId(GWEN_CONFIGMGR *cfg,
646  const char *groupName,
647  uint32_t uid,
648  int doCheck,
649  char *buffer,
650  uint32_t bufferLen) {
651  GWEN_CONFIGMGR_DIR *xcfg;
652  int rv;
653  char ubuf[64];
654 
655  assert(cfg);
656  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
657  assert(xcfg);
658 
659  snprintf(ubuf, sizeof(ubuf)-1, "%08x", uid);
660  ubuf[sizeof(ubuf)-1]=0;
661 
662  if (doCheck) {
663  GWEN_BUFFER *nbuf;
664 
665  /* check whether that group already exists */
666  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
667  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, ubuf, nbuf);
668 
669  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
670  GWEN_PATH_FLAGS_CHECKROOT |
671  GWEN_PATH_FLAGS_NAMEMUSTEXIST |
672  GWEN_PATH_FLAGS_VARIABLE);
673  if (rv>=0) {
674  DBG_INFO(GWEN_LOGDOMAIN, "Path already exists [%s]: %d",
675  GWEN_Buffer_GetStart(nbuf), rv);
676  GWEN_Buffer_free(nbuf);
677  return rv;
678  }
679  GWEN_Buffer_free(nbuf);
680 
681  /* update lastId if necessary */
682  rv=GWEN_ConfigMgrDir__UpdateLastUniqueId(cfg, groupName, uid);
683  if (rv<0) {
684  DBG_INFO(GWEN_LOGDOMAIN, "Could not update unique id (%d)", rv);
685  return rv;
686  }
687  }
688 
689  /* return new id */
690  strncpy(buffer, ubuf, bufferLen-1);
691  buffer[bufferLen-1]=0;
692 
693  return 0;
694 }
695 
696 
697 
698 int GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg,
699  const char *groupName,
700  const char *subGroupName) {
701  GWEN_BUFFER *nbuf;
702  GWEN_CONFIGMGR_DIR *xcfg;
703  int rv;
704  GWEN_FSLOCK *lck;
705  GWEN_FSLOCK_RESULT res;
706 
707  assert(cfg);
708  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
709  assert(xcfg);
710 
711  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
712  GWEN_ConfigMgrDir_AddGroupFileName(cfg, groupName, subGroupName, nbuf);
713 
714  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
715  GWEN_PATH_FLAGS_CHECKROOT |
716  GWEN_PATH_FLAGS_VARIABLE);
717  if (rv<0) {
718  DBG_INFO(GWEN_LOGDOMAIN, "Could not access [%s]: %d",
719  GWEN_Buffer_GetStart(nbuf), rv);
720  GWEN_Buffer_free(nbuf);
721  return rv;
722  }
723 
724  lck=GWEN_ConfigMgrDir_FindLock(cfg, GWEN_Buffer_GetStart(nbuf));
725  if (lck) {
726  DBG_ERROR(GWEN_LOGDOMAIN,
727  "Group [%s/%s] is still locked",
728  groupName, subGroupName);
729  GWEN_Buffer_free(nbuf);
730  return GWEN_ERROR_LOCK;
731  }
732 
733  lck=GWEN_FSLock_new(GWEN_Buffer_GetStart(nbuf), GWEN_FSLock_TypeFile);
734  res=GWEN_FSLock_Lock(lck, 60000, 0);
735  if (res!=GWEN_FSLock_ResultOk) {
736  DBG_ERROR(GWEN_LOGDOMAIN,
737  "Could not lock group [%s/%s]: %d",
738  groupName, subGroupName, res);
739  GWEN_FSLock_free(lck);
740  GWEN_Buffer_free(nbuf);
741  return GWEN_ERROR_LOCK;
742  }
743 
744  unlink(GWEN_Buffer_GetStart(nbuf));
745 
746  GWEN_FSLock_Unlock(lck);
747  GWEN_FSLock_free(lck);
748  GWEN_Buffer_free(nbuf);
749 
750  return 0;
751 }
752 
753 
754 
755 int GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg,
756  GWEN_STRINGLIST *sl) {
757  GWEN_CONFIGMGR_DIR *xcfg;
758  int rv;
759 
760  assert(cfg);
761  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
762  assert(xcfg);
763 
764  assert(xcfg->folder);
765 
766  rv=GWEN_Directory_GetDirEntries(xcfg->folder, sl, NULL);
767  if (rv<0) {
768  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
769  return rv;
770  }
771 
772  return 0;
773 }
774 
775 
776 
777 int GWEN_ConfigMgrDir_ListSubGroups(GWEN_CONFIGMGR *cfg,
778  const char *groupName,
779  GWEN_STRINGLIST *sl) {
780  GWEN_BUFFER *nbuf;
781  GWEN_CONFIGMGR_DIR *xcfg;
782  int rv;
783  GWEN_STRINGLIST *rawsl;
784 
785  assert(cfg);
786  xcfg=GWEN_INHERIT_GETDATA(GWEN_CONFIGMGR, GWEN_CONFIGMGR_DIR, cfg);
787  assert(xcfg);
788 
789  nbuf=GWEN_Buffer_new(0, 256, 0, 1);
790  GWEN_ConfigMgrDir_AddGroupDirName(cfg, groupName, nbuf);
791 
792  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nbuf),
793  GWEN_PATH_FLAGS_CHECKROOT |
794  GWEN_PATH_FLAGS_PATHMUSTEXIST |
795  GWEN_PATH_FLAGS_NAMEMUSTEXIST);
796  if (rv<0) {
797  DBG_INFO(GWEN_LOGDOMAIN, "Path not found (%d)", rv);
798  GWEN_Buffer_free(nbuf);
799  return 0;
800  }
801 
802  rawsl=GWEN_StringList_new();
803  rv=GWEN_Directory_GetFileEntries(GWEN_Buffer_GetStart(nbuf), rawsl, "*.conf");
804  if (rv<0) {
805  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
806  GWEN_StringList_free(rawsl);
807  GWEN_Buffer_free(nbuf);
808  return rv;
809  }
810  else {
811  GWEN_STRINGLISTENTRY *se;
812  GWEN_BUFFER *tbuf;
813 
814  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
815  se=GWEN_StringList_FirstEntry(rawsl);
816  while(se) {
817  char buffer[256];
818  char *p;
819 
820  strncpy(buffer, GWEN_StringListEntry_Data(se), sizeof(buffer)-1);
821  buffer[sizeof(buffer)-1]=0;
822  p=strrchr(buffer, '.');
823  if (p) {
824  *p=0;
825  GWEN_Text_UnescapeToBuffer(buffer, tbuf);
826  GWEN_StringList_AppendString(sl, GWEN_Buffer_GetStart(tbuf), 0, 1);
827  GWEN_Buffer_Reset(tbuf);
828  }
829 
830  se=GWEN_StringListEntry_Next(se);
831  }
832  GWEN_Buffer_free(tbuf);
833  GWEN_StringList_free(rawsl);
834  GWEN_Buffer_free(nbuf);
835  return 0;
836  }
837 }
838 
839 
840 
841 
842 
GWEN_ConfigMgrDir_DeleteGroup
int GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:698
GWEN_ConfigMgrDir_FindLock
GWEN_FSLOCK * GWEN_ConfigMgrDir_FindLock(GWEN_CONFIGMGR *cfg, const char *fname)
Definition: cfgdir.c:397
GWEN_Url_free
void GWEN_Url_free(GWEN_URL *st)
Definition: url.c:37
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:223
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:369
GWEN_ConfigMgrDir_FreeData
GWENHYWFAR_CB void GWEN_ConfigMgrDir_FreeData(GWEN_UNUSED void *bp, void *p)
Definition: cfgdir.c:130
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:615
GWEN_ConfigMgrDir_ListGroups
int GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg, GWEN_STRINGLIST *sl)
Definition: cfgdir.c:755
GWEN_ConfigMgr_SetDeleteGroupFn
GWEN_CONFIGMGR_DELETEGROUP_FN GWEN_ConfigMgr_SetDeleteGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_DELETEGROUP_FN f)
Definition: configmgr.c:220
GWEN_ConfigMgr_new
GWEN_CONFIGMGR * GWEN_ConfigMgr_new(const char *url)
Definition: configmgr.c:118
GWEN_ConfigMgrDir_AddGroupFileName
void GWEN_ConfigMgrDir_AddGroupFileName(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_BUFFER *nbuf)
Definition: cfgdir.c:363
GWEN_FREE_OBJECT
#define GWEN_FREE_OBJECT(varname)
Definition: memory.h:92
NULL
#define NULL
Definition: binreloc.c:290
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:777
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:142
DBG_WARN
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:118
GWEN_ConfigMgrDir_GetGroup
int GWEN_ConfigMgrDir_GetGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName, GWEN_DB_NODE **pDb)
Definition: cfgdir.c:420
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:132
GWEN_ConfigMgrDir_AddGroupDirName
void GWEN_ConfigMgrDir_AddGroupDirName(GWEN_CONFIGMGR *cfg, const char *groupName, GWEN_BUFFER *nbuf)
Definition: cfgdir.c:335
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:239
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:518
GWEN_StringList_FirstEntry
GWEN_STRINGLISTENTRY * GWEN_StringList_FirstEntry(const GWEN_STRINGLIST *sl)
Definition: stringlist.c:352
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:684
GWEN_StringListEntry_Data
const char * GWEN_StringListEntry_Data(const GWEN_STRINGLISTENTRY *se)
Definition: stringlist.c:366
GWEN_ConfigMgrDir_new
GWEN_CONFIGMGR * GWEN_ConfigMgrDir_new(const char *url)
Definition: cfgdir.c:84
configmgr_dir_factory
GWEN_PLUGIN * configmgr_dir_factory(GWEN_PLUGIN_MANAGER *pm, const char *modName, const char *fileName)
Definition: cfgdir.c:68
GWEN_StringList_free
void GWEN_StringList_free(GWEN_STRINGLIST *sl)
Definition: stringlist.c:57
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:645
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:230
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:194
GWEN_ConfigMgr_SetMkUniqueIdFromIdFn
GWEN_CONFIGMGR_MKUNIQUEIDFROMID_FN GWEN_ConfigMgr_SetMkUniqueIdFromIdFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_MKUNIQUEIDFROMID_FN f)
Definition: configmgr.c:207
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:1326
GWEN_ConfigMgrDir__UpdateLastUniqueId
int GWEN_ConfigMgrDir__UpdateLastUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t uid)
Definition: cfgdir.c:247
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:181
GWEN_ConfigMgr_Plugin_SetFactoryFn
void GWEN_ConfigMgr_Plugin_SetFactoryFn(GWEN_PLUGIN *pl, GWEN_CONFIGMGR_PLUGIN_FACTORYFN f)
Definition: configmgr.c:402
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:507
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:83
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:176
GWEN_Text_UnescapeToBuffer
int GWEN_Text_UnescapeToBuffer(const char *src, GWEN_BUFFER *buf)
Definition: text.c:1360
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:377
GWEN_ConfigMgrDir__GetUniqueId
int GWEN_ConfigMgrDir__GetUniqueId(GWEN_CONFIGMGR *cfg, const char *groupName, uint32_t *pUniqueId)
Definition: cfgdir.c:159
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:571
GWEN_StringListEntry_Next
GWEN_STRINGLISTENTRY * GWEN_StringListEntry_Next(const GWEN_STRINGLISTENTRY *se)
Definition: stringlist.c:359
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:168
DBG_INFO
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:164
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:219
GWEN_ConfigMgr_SetListSubGroupsFn
GWEN_CONFIGMGR_LISTSUBGROUPS_FN GWEN_ConfigMgr_SetListSubGroupsFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_LISTSUBGROUPS_FN f)
Definition: configmgr.c:246
GWEN_DB_ReadFile
GWENHYWFAR_API int GWEN_DB_ReadFile(GWEN_DB_NODE *n, const char *fname, uint32_t dbflags)
Definition: dbrw.c:990
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:131
GWEN_Directory_GetFileEntries
GWENHYWFAR_API int GWEN_Directory_GetFileEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition: directory_all.c:462
GWEN_ConfigMgr_SetSetGroupFn
GWEN_CONFIGMGR_SETGROUP_FN GWEN_ConfigMgr_SetSetGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_SETGROUP_FN f)
Definition: configmgr.c:155
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:528
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:233
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:467
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_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:211
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:145
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:1014
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.6