gwenhywfar  5.10.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 
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 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 
478 int 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 
530 int 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 
562 int 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 
616 int 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 
661 int 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 
692 int 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 
754 int 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 
812 int 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 
835 int 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 
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:40
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:53
GWEN_ConfigMgrDir_DeleteGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_DeleteGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:754
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:421
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:108
GWEN_ConfigMgr_SetDeleteGroupFn
GWEN_CONFIGMGR_DELETEGROUP_FN GWEN_ConfigMgr_SetDeleteGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_DELETEGROUP_FN f)
Definition: configmgr.c:245
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_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:61
NULL
#define NULL
Definition: binreloc.c:300
GWEN_PATH_FLAGS_CREATE_GROUP
#define GWEN_PATH_FLAGS_CREATE_GROUP
Definition: path.h:96
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
GWEN_ConfigMgrDir_ListGroups
int GWENHYWFAR_CB GWEN_ConfigMgrDir_ListGroups(GWEN_CONFIGMGR *cfg, GWEN_STRINGLIST *sl)
Definition: cfgdir.c:812
DBG_WARN
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:125
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:42
GWEN_StringList_FirstEntry
GWEN_STRINGLISTENTRY * GWEN_StringList_FirstEntry(const GWEN_STRINGLIST *sl)
Definition: stringlist.c:390
GWEN_Buffer_Reset
void GWEN_Buffer_Reset(GWEN_BUFFER *bf)
Definition: buffer.c:650
GWEN_StringListEntry_Data
const char * GWEN_StringListEntry_Data(const GWEN_STRINGLISTENTRY *se)
Definition: stringlist.c:406
GWEN_ConfigMgrDir_new
GWEN_CONFIGMGR * GWEN_ConfigMgrDir_new(const char *url)
Definition: cfgdir.c:87
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
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:62
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:55
GWEN_FSLock_new
GWENHYWFAR_API GWEN_FSLOCK * GWEN_FSLock_new(const char *fname, GWEN_FSLOCK_TYPE t)
GWEN_ConfigMgrDir_LockGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_LockGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:562
GWEN_StringList_AppendString
int GWEN_StringList_AppendString(GWEN_STRINGLIST *sl, const char *s, int take, int checkDouble)
Definition: stringlist.c:245
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:1376
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:56
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_ConfigMgrDir_HasGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_HasGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:530
GWEN_Directory_GetDirEntries
GWENHYWFAR_API int GWEN_Directory_GetDirEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition: directory_all.c:536
GWEN_Buffer_free
void GWEN_Buffer_free(GWEN_BUFFER *bf)
Definition: buffer.c:89
GWEN_BUFFER
struct GWEN_BUFFER GWEN_BUFFER
A dynamically resizeable text buffer.
Definition: buffer.h:38
GWEN_Url_GetServer
const char * GWEN_Url_GetServer(const GWEN_URL *st)
Definition: url.c:186
GWEN_Text_UnescapeToBuffer
int GWEN_Text_UnescapeToBuffer(const char *src, GWEN_BUFFER *buf)
Definition: text.c:1411
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_StringListEntry_Next
GWEN_STRINGLISTENTRY * GWEN_StringListEntry_Next(const GWEN_STRINGLISTENTRY *se)
Definition: stringlist.c:398
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:181
GWEN_ConfigMgrDir_UnlockGroup
int GWENHYWFAR_CB GWEN_ConfigMgrDir_UnlockGroup(GWEN_CONFIGMGR *cfg, const char *groupName, const char *subGroupName)
Definition: cfgdir.c:616
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:237
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:173
GWEN_Directory_GetFileEntries
GWENHYWFAR_API int GWEN_Directory_GetFileEntries(const char *folder, GWEN_STRINGLIST *sl, const char *mask)
Definition: directory_all.c:490
GWEN_ConfigMgr_SetSetGroupFn
GWEN_CONFIGMGR_SETGROUP_FN GWEN_ConfigMgr_SetSetGroupFn(GWEN_CONFIGMGR *mgr, GWEN_CONFIGMGR_SETGROUP_FN f)
Definition: configmgr.c:160
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_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_ERROR_INTERNAL
#define GWEN_ERROR_INTERNAL
Definition: error.h:125
GWEN_FSLock_ResultOk
Definition: fslock.h:72
GWEN_FSLock_Unlock
GWENHYWFAR_API GWEN_FSLOCK_RESULT GWEN_FSLock_Unlock(GWEN_FSLOCK *fl)
GWEN_ConfigMgrDir_ListSubGroups
int GWENHYWFAR_CB GWEN_ConfigMgrDir_ListSubGroups(GWEN_CONFIGMGR *cfg, const char *groupName, GWEN_STRINGLIST *sl)
Definition: cfgdir.c:835
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_INHERIT_SETDATA
#define GWEN_INHERIT_SETDATA(bt, t, element, data, fn)
Definition: inherit.h:292
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_StringList_new
GWEN_STRINGLIST * GWEN_StringList_new(void)
Definition: stringlist.c:50
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:225
GWEN_UNUSED
#define GWEN_UNUSED
Definition: gwenhywfarapi.h:150
GWEN_Buffer_AppendString
int GWEN_Buffer_AppendString(GWEN_BUFFER *bf, const char *buffer)
Definition: buffer.c:989
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.14