gwenhywfar  4.7.0beta
dbio.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Wed Mar 31 2004
3  copyright : (C) 2004-2010 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 #define DISABLE_DEBUGLOG
31 
32 #include "dbio_p.h"
33 #include <gwenhywfar/gwenhywfar.h>
34 #include <gwenhywfar/misc.h>
35 #include <gwenhywfar/debug.h>
36 #include <gwenhywfar/path.h>
37 #include <gwenhywfar/text.h>
38 #include <gwenhywfar/directory.h>
39 #include <gwenhywfar/syncio.h>
40 #include <gwenhywfar/syncio_file.h>
41 #include <gwenhywfar/syncio_memory.h>
42 #include <gwenhywfar/fslock.h>
43 #include <gwenhywfar/pathmanager.h>
44 
45 
46 /* TODO: #include <gwenhywfar/plugin.h> */
47 
48 #include <stdlib.h>
49 #include <assert.h>
50 #include <string.h>
51 #include <errno.h>
52 #include <ctype.h>
53 
54 #include <sys/types.h>
55 #ifdef HAVE_SYS_STAT_H
56 # include <sys/stat.h>
57 #endif
58 #ifdef HAVE_FCNTL_H
59 # include <fcntl.h>
60 #endif
61 #ifdef HAVE_UNISTD_H
62 # include <unistd.h>
63 #endif
64 
65 
66 #ifdef OS_WIN32
67 # define DIRSEP "\\"
68 # include <windows.h>
69 #else
70 # define DIRSEP "/"
71 #endif
72 
73 
74 
77 
78 GWEN_INHERIT(GWEN_PLUGIN, GWEN_DBIO_PLUGIN)
79 
80 
83  int err;
84  GWEN_STRINGLIST *sl;
85 
88  if (err) {
89  DBG_ERROR(GWEN_LOGDOMAIN, "Could not register DBIO plugin manager");
90  return err;
91  }
92 
93  /* create plugin paths */
95  if (sl) {
97  GWEN_BUFFER *pbuf;
98 
99  pbuf=GWEN_Buffer_new(0, 256, 0, 1);
100 
102  while(se) {
105  DBG_INFO(GWEN_LOGDOMAIN, "Adding plugin path [%s]",
106  GWEN_Buffer_GetStart(pbuf));
108  GWEN_Buffer_GetStart(pbuf));
109  GWEN_Buffer_Reset(pbuf);
111  }
112  GWEN_Buffer_free(pbuf);
114  }
115 
116  return 0;
117 }
118 
119 
120 
123 
125  if (pm) {
126  int rv;
127 
129  if (rv) {
131  "Could not unregister DBIO plugin manager (%d)", rv);
132  return rv;
133  }
134  else
136  }
137 
138  return 0;
139 }
140 
141 
142 
143 
144 
146  const char *name,
147  const char *fileName) {
148  GWEN_PLUGIN *pl;
149  GWEN_DBIO_PLUGIN *pldbio;
150 
151  pl=GWEN_Plugin_new(pm, name, fileName);
152  GWEN_NEW_OBJECT(GWEN_DBIO_PLUGIN, pldbio);
153  GWEN_INHERIT_SETDATA(GWEN_PLUGIN, GWEN_DBIO_PLUGIN, pl, pldbio,
155 
156  return pl;
157 }
158 
159 
160 
162  GWEN_DBIO_PLUGIN *pldbio;
163 
164  pldbio=(GWEN_DBIO_PLUGIN*)p;
165  GWEN_FREE_OBJECT(pldbio);
166 }
167 
168 
169 
171  GWEN_DBIO_PLUGIN *pldbio;
172 
173  assert(pl);
174  pldbio=GWEN_INHERIT_GETDATA(GWEN_PLUGIN, GWEN_DBIO_PLUGIN, pl);
175  assert(pldbio);
176 
177  assert(pldbio->factoryFn);
178  return pldbio->factoryFn(pl);
179 }
180 
181 
182 
185  GWEN_DBIO_PLUGIN *pldbio;
186 
187  assert(pl);
188  pldbio=GWEN_INHERIT_GETDATA(GWEN_PLUGIN, GWEN_DBIO_PLUGIN, pl);
189  assert(pldbio);
190 
191  pldbio->factoryFn=f;
192 }
193 
194 
195 
196 
197 
198 
199 
200 
201 GWEN_DBIO *GWEN_DBIO_new(const char *name, const char *descr){
202  GWEN_DBIO *dbio;
203 
204  assert(name);
205  GWEN_NEW_OBJECT(GWEN_DBIO, dbio);
206  GWEN_LIST_INIT(GWEN_DBIO, dbio);
208  dbio->name=strdup(name);
209  if (descr)
210  dbio->descr=strdup(descr);
211 
212  dbio->usage=1;
213  return dbio;
214 }
215 
216 
217 
219  if (dbio) {
220  assert(dbio->usage);
221  if (--(dbio->usage)==0) {
223  GWEN_LIST_FINI(GWEN_DBIO, dbio);
224 
225  free(dbio->name);
226  free(dbio->descr);
227 
228  GWEN_FREE_OBJECT(dbio);
229  }
230  }
231 }
232 
233 
234 
236  assert(dbio);
237  dbio->usage++;
238 }
239 
240 
241 
243  GWEN_SYNCIO *sio,
244  GWEN_DB_NODE *db,
245  GWEN_DB_NODE *params,
246  uint32_t flags) {
247  assert(dbio);
248  assert(sio);
249  assert(db);
250 
252  DBG_ERROR(GWEN_LOGDOMAIN, "GWEN_SYNCIO %s not connected; did you forget to call GWEN_SyncIo_Connect()?", GWEN_SyncIo_GetTypeName(sio));
253  return -1;
254  }
255 
256  if (dbio->importFn)
257  return dbio->importFn(dbio, sio, db, params, flags);
258  else {
259  DBG_INFO(GWEN_LOGDOMAIN, "No import function set");
260  return -1;
261  }
262 }
263 
264 
265 
267  GWEN_SYNCIO *sio,
268  GWEN_DB_NODE *db,
269  GWEN_DB_NODE *params,
270  uint32_t flags) {
271  assert(dbio);
272  assert(sio);
273  assert(db);
274 
275  if (dbio->exportFn)
276  return dbio->exportFn(dbio, sio, db, params, flags);
277  else {
278  DBG_INFO(GWEN_LOGDOMAIN, "No export function set");
279  return -1;
280  }
281 }
282 
283 
284 
286  const char *fname) {
287  assert(dbio);
288  assert(fname);
289 
290  if (dbio->checkFileFn)
291  return dbio->checkFileFn(dbio, fname);
292  else {
293  DBG_INFO(GWEN_LOGDOMAIN, "No checkFile function set");
295  }
296 }
297 
298 
299 
300 const char *GWEN_DBIO_GetName(const GWEN_DBIO *dbio){
301  assert(dbio);
302  return dbio->name;
303 }
304 
305 
306 
307 const char *GWEN_DBIO_GetDescription(const GWEN_DBIO *dbio){
308  assert(dbio);
309  return dbio->descr;
310 }
311 
312 
313 
315  assert(dbio);
316  dbio->importFn=f;
317 }
318 
319 
320 
322  assert(dbio);
323  dbio->exportFn=f;
324 }
325 
326 
328  assert(dbio);
329  dbio->checkFileFn=f;
330 }
331 
332 
333 
334 GWEN_DBIO *GWEN_DBIO_GetPlugin(const char *modname){
336  GWEN_PLUGIN *pl;
337  GWEN_DBIO *dbio;
338 
340  if (!pm) {
341  DBG_ERROR(GWEN_LOGDOMAIN, "No plugin manager for \"dbio\" found");
342  return 0;
343  }
344 
345  pl=GWEN_PluginManager_GetPlugin(pm, modname);
346  if (!pl) {
347  DBG_INFO(GWEN_LOGDOMAIN, "DBIO-Plugin \"%s\" not found", modname);
348  return 0;
349  }
350 
351  dbio=GWEN_DBIO_Plugin_Factory(pl);
352  if (!dbio) {
354  "Plugin did not create a GWEN_DBIO");
355  }
356  return dbio;
357 }
358 
359 
360 
362  const char *fname,
363  GWEN_DB_NODE *db,
364  GWEN_DB_NODE *params,
365  uint32_t dbflags) {
366  int rv;
367  GWEN_FSLOCK *lck=0;
368  GWEN_SYNCIO *sio;
369 
370  /* if locking requested */
371  if (dbflags & GWEN_DB_FLAGS_LOCKFILE) {
372  GWEN_FSLOCK_RESULT res;
373 
375  assert(lck);
377  if (res!=GWEN_FSLock_ResultOk) {
379  "Could not apply lock to file \"%s\" (%d)",
380  fname, res);
381  GWEN_FSLock_free(lck);
382  return -1;
383  }
384  }
385 
386  /* open file */
388  if (dbflags & GWEN_DB_FLAGS_APPEND_FILE)
395  rv=GWEN_SyncIo_Connect(sio);
396  if (rv<0) {
397  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
398  GWEN_SyncIo_free(sio);
399  if (lck) {
400  GWEN_FSLock_Unlock(lck);
401  GWEN_FSLock_free(lck);
402  }
403  return rv;
404  }
405 
406  rv=GWEN_DBIO_Export(dbio, sio, db, params, dbflags);
407  if (rv<0) {
408  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
410  GWEN_SyncIo_free(sio);
411  if (lck) {
412  GWEN_FSLock_Unlock(lck);
413  GWEN_FSLock_free(lck);
414  }
415  return rv;
416  }
417 
418  rv=GWEN_SyncIo_Disconnect(sio);
419  if (rv<0) {
420  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
421  GWEN_SyncIo_free(sio);
422  if (lck) {
423  GWEN_FSLock_Unlock(lck);
424  GWEN_FSLock_free(lck);
425  }
426  return rv;
427  }
428  GWEN_SyncIo_free(sio);
429 
430  /* remove lock, if any */
431  if (lck) {
432  GWEN_FSLOCK_RESULT res;
433 
434  res=GWEN_FSLock_Unlock(lck);
435  if (res!=GWEN_FSLock_ResultOk) {
437  "Could not remove lock on file \"%s\" (%d)",
438  fname, res);
439  }
440  GWEN_FSLock_free(lck);
441  }
442 
443  return 0;
444 }
445 
446 
447 
449  GWEN_BUFFER *buf,
450  GWEN_DB_NODE *db,
451  GWEN_DB_NODE *params,
452  uint32_t flags) {
453  GWEN_SYNCIO *sio;
454  int rv;
455 
456  /* create SyncIO, don't take over buf */
457  sio=GWEN_SyncIo_Memory_new(buf, 0);
458  rv=GWEN_DBIO_Export(dbio, sio, db, params, flags);
459  if (rv<0) {
460  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
461  GWEN_SyncIo_free(sio);
462  return rv;
463  }
464 
465  GWEN_SyncIo_free(sio);
466  return 0;
467 }
468 
469 
470 
472  const char *fname,
473  GWEN_DB_NODE *db,
474  GWEN_DB_NODE *params,
475  uint32_t dbflags) {
476  GWEN_SYNCIO *sio;
477  int rv;
478  GWEN_FSLOCK *lck=0;
479 
480  /* if locking requested */
481  if (dbflags & GWEN_DB_FLAGS_LOCKFILE) {
482  GWEN_FSLOCK_RESULT res;
483 
485  assert(lck);
487  if (res!=GWEN_FSLock_ResultOk) {
489  "Could not apply lock to file \"%s\" (%d)",
490  fname, res);
491  GWEN_FSLock_free(lck);
492  return GWEN_ERROR_IO;
493  }
494  }
495 
498  rv=GWEN_SyncIo_Connect(sio);
499  if (rv<0) {
500  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
501  GWEN_SyncIo_free(sio);
502  if (lck) {
503  GWEN_FSLock_Unlock(lck);
504  GWEN_FSLock_free(lck);
505  }
506  return rv;
507  }
508 
509  /* read from file */
510  rv=GWEN_DBIO_Import(dbio, sio, db, params, dbflags);
511  if (rv<0) {
512  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
514  GWEN_SyncIo_free(sio);
515  if (lck) {
516  GWEN_FSLock_Unlock(lck);
517  GWEN_FSLock_free(lck);
518  }
519  return rv;
520  }
521 
522  /* close io layer */
524  GWEN_SyncIo_free(sio);
525 
526  /* remove lock, if any */
527  if (lck) {
528  GWEN_FSLOCK_RESULT res;
529 
530  res=GWEN_FSLock_Unlock(lck);
531  if (res!=GWEN_FSLock_ResultOk) {
533  "Could not remove lock on file \"%s\" (%d)",
534  fname, res);
535  }
536  GWEN_FSLock_free(lck);
537  }
538 
539  return 0;
540 }
541 
542 
543 
544 
545 
546 
547 
548 
549 
550 
551 
552 
553 
554