Put local variables footer in all c, h files.
[idzebra-moved-to-github.git] / bfile / bfile.c
1 /* $Id: bfile.c,v 1.47 2006-05-10 08:13:17 adam Exp $
2    Copyright (C) 1995-2005
3    Index Data ApS
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #ifdef WIN32
28 #include <io.h>
29 #endif
30
31 #if HAVE_UNISTD_H
32 #include <unistd.h>
33 #endif
34
35 #include <yaz/xmalloc.h>
36 #include <idzebra/util.h>
37 #include <idzebra/bfile.h>
38 #include "mfile.h"
39 #include "cfile.h"
40
41 struct BFile_struct
42 {
43     MFile mf;
44     Zebra_lock_rdwr rdwr_lock;
45     struct CFile_struct *cf;
46     char *alloc_buf;
47     int block_size;
48     int alloc_buf_size;
49     zint last_block;
50     zint free_list;
51     zint root_block;
52     char *magic;
53     int header_dirty;
54 };
55
56 struct BFiles_struct {
57     MFile_area commit_area;
58     MFile_area_struct *register_area;
59     char *base;
60     char *cache_fname;
61 };
62
63 BFiles bfs_create (const char *spec, const char *base)
64 {
65     BFiles bfs = (BFiles) xmalloc (sizeof(*bfs));
66     bfs->commit_area = NULL;
67     bfs->base = 0;
68     bfs->cache_fname = 0;
69     if (base)
70         bfs->base = xstrdup (base);
71     bfs->register_area = mf_init("register", spec, base);
72     if (!bfs->register_area)
73     {
74         bfs_destroy(bfs);
75         return 0;
76     }
77     return bfs;
78 }
79
80 void bfs_destroy (BFiles bfs)
81 {
82     if (!bfs)
83         return;
84     xfree (bfs->cache_fname);
85     xfree (bfs->base);
86     mf_destroy (bfs->commit_area);
87     mf_destroy (bfs->register_area);
88     xfree (bfs);
89 }
90
91 static FILE *open_cache (BFiles bfs, const char *flags)
92 {
93     FILE *file;
94
95     file = fopen (bfs->cache_fname, flags);
96     return file;
97 }
98
99 static void unlink_cache (BFiles bfs)
100 {
101     unlink (bfs->cache_fname);
102 }
103
104 ZEBRA_RES bf_cache (BFiles bfs, const char *spec)
105 {
106     if (spec)
107     {
108         yaz_log (YLOG_LOG, "enabling shadow spec=%s", spec);
109         if (!bfs->commit_area)
110             bfs->commit_area = mf_init ("shadow", spec, bfs->base);
111         if (bfs->commit_area)
112         {
113             bfs->cache_fname = xmalloc (strlen(bfs->commit_area->dirs->name)+
114                                        8);
115             strcpy (bfs->cache_fname, bfs->commit_area->dirs->name);
116             strcat (bfs->cache_fname, "/cache");
117             yaz_log (YLOG_LOG, "cache_fname = %s", bfs->cache_fname);
118         }
119         else
120         {
121             yaz_log(YLOG_WARN, "shadow could not be enabled");
122             return ZEBRA_FAIL;
123         }
124     }
125     else
126         bfs->commit_area = NULL;
127     return ZEBRA_OK;
128 }
129
130 int bf_close (BFile bf)
131 {
132     zebra_lock_rdwr_destroy (&bf->rdwr_lock);
133     if (bf->cf)
134         cf_close (bf->cf);
135     mf_close (bf->mf);
136     xfree(bf->alloc_buf);
137     xfree(bf->magic);
138     xfree(bf);
139     return 0;
140 }
141
142 #define HEADER_SIZE 256
143
144 BFile bf_xopen(BFiles bfs, const char *name, int block_size, int wrflag,
145                const char *magic, int *read_version,
146                const char **more_info)
147 {
148     char read_magic[40];
149     int l = 0;
150     int i = 0;
151     char *hbuf;
152     zint pos = 0;
153     BFile bf = bf_open(bfs, name, block_size, wrflag);
154
155     if (!bf)
156         return 0;
157      /* HEADER_SIZE is considered enough for our header */
158     if (bf->block_size < HEADER_SIZE)
159         bf->alloc_buf_size = HEADER_SIZE;
160     else
161         bf->alloc_buf_size = bf->block_size;
162         
163     hbuf = bf->alloc_buf = xmalloc(bf->alloc_buf_size);
164
165     /* fill-in default values */
166     bf->free_list = 0;
167     bf->root_block = bf->last_block = HEADER_SIZE / bf->block_size + 1;
168     bf->magic = xstrdup(magic);
169
170     if (!bf_read(bf, pos, 0, 0, hbuf + pos * bf->block_size))
171     {
172         if (wrflag)
173             bf->header_dirty = 1;
174         return bf;
175     }
176     while(hbuf[pos * bf->block_size + i] != '\0')
177     {
178         if (i == bf->block_size)
179         {   /* end of block at pos reached .. */
180             if (bf->alloc_buf_size  < (pos+1) * bf->block_size)
181             {
182                 /* not room for all in alloc_buf_size */
183                 yaz_log(YLOG_WARN, "bad header for %s (3)", magic);
184                 bf_close(bf);
185                 return 0;
186             }
187             /* read next block in header */
188             pos++;
189             if (!bf_read(bf, pos, 0, 0, hbuf + pos * bf->block_size))
190             {
191                 yaz_log(YLOG_WARN, "missing header block %s (4)", magic);
192                 bf_close(bf);
193                 return 0;
194             }
195             i = 0; /* pos within block is reset */
196         }
197         else
198             i++;
199     }
200     if (sscanf(hbuf, "%39s %d " ZINT_FORMAT " " ZINT_FORMAT "%n",
201                read_magic, read_version, &bf->last_block,
202                &bf->free_list, &l) < 4 && l)  /* if %n is counted, it's 5 */
203     {
204         yaz_log(YLOG_WARN, "bad header for %s (1)", magic);
205         bf_close(bf);
206         return 0;
207     }
208     if (strcmp(read_magic, magic))
209     {
210         yaz_log(YLOG_WARN, "bad header for %s (2)", magic);
211         bf_close(bf);
212         return 0;
213     }
214     if (hbuf[l] == ' ')
215         l++;
216     if (more_info)
217         *more_info = hbuf + l;
218     return bf;
219 }
220
221 int bf_xclose (BFile bf, int version, const char *more_info)
222 {
223     if (bf->header_dirty)
224     {
225         zint pos = 0;
226         assert(bf->alloc_buf);
227         assert(bf->magic);
228         sprintf(bf->alloc_buf, "%s %d " ZINT_FORMAT " " ZINT_FORMAT " ", 
229                 bf->magic, version, bf->last_block, bf->free_list);
230         if (more_info)
231             strcat(bf->alloc_buf, more_info);
232         while (1)
233         {
234             bf_write(bf, pos, 0, 0, bf->alloc_buf + pos * bf->block_size);
235             pos++;
236             if (pos * bf->block_size > strlen(bf->alloc_buf))
237                 break;
238         }
239     }
240     return bf_close(bf);
241 }
242
243 BFile bf_open (BFiles bfs, const char *name, int block_size, int wflag)
244 {
245     BFile bf = (BFile) xmalloc(sizeof(struct BFile_struct));
246
247     bf->alloc_buf = 0;
248     bf->magic = 0;
249     bf->block_size = block_size;
250     bf->header_dirty = 0;
251     if (bfs->commit_area)
252     {
253         int first_time;
254
255         bf->mf = mf_open (bfs->register_area, name, block_size, 0);
256         bf->cf = cf_open (bf->mf, bfs->commit_area, name, block_size,
257                            wflag, &first_time);
258         if (first_time)
259         {
260             FILE *outf;
261
262             outf = open_cache(bfs, "ab");
263             if (!outf)
264             {
265                 yaz_log(YLOG_FATAL|YLOG_ERRNO, "open %s", bfs->cache_fname);
266                 exit(1);
267             }
268             fprintf(outf, "%s %d\n", name, block_size);
269             fclose(outf);
270         }
271     }
272     else
273     {
274         bf->mf = mf_open(bfs->register_area, name, block_size, wflag);
275         bf->cf = NULL;
276     }
277     if (!bf->mf)
278     {
279         yaz_log(YLOG_FATAL, "mf_open failed for %s", name);
280         xfree(bf);
281         return 0;
282     }
283     zebra_lock_rdwr_init(&bf->rdwr_lock);
284     return bf;
285 }
286
287 int bf_read (BFile bf, zint no, int offset, int nbytes, void *buf)
288 {
289     int r;
290
291     zebra_lock_rdwr_rlock (&bf->rdwr_lock);
292     if (bf->cf)
293     {
294         if ((r = cf_read (bf->cf, no, offset, nbytes, buf)) == -1)
295             r = mf_read (bf->mf, no, offset, nbytes, buf);
296     }
297     else 
298         r = mf_read (bf->mf, no, offset, nbytes, buf);
299     zebra_lock_rdwr_runlock (&bf->rdwr_lock);
300     return r;
301 }
302
303 int bf_write (BFile bf, zint no, int offset, int nbytes, const void *buf)
304 {
305     int r;
306     zebra_lock_rdwr_wlock (&bf->rdwr_lock);
307     if (bf->cf)
308         r = cf_write (bf->cf, no, offset, nbytes, buf);
309     else
310         r = mf_write (bf->mf, no, offset, nbytes, buf);
311     zebra_lock_rdwr_wunlock (&bf->rdwr_lock);
312     return r;
313 }
314
315 int bf_commitExists (BFiles bfs)
316 {
317     FILE *inf;
318
319     inf = open_cache (bfs, "rb");
320     if (inf)
321     {
322         fclose (inf);
323         return 1;
324     }
325     return 0;
326 }
327
328 void bf_reset (BFiles bfs)
329 {
330     if (!bfs)
331         return;
332     mf_reset (bfs->commit_area);
333     mf_reset (bfs->register_area);
334 }
335
336 void bf_commitExec (BFiles bfs)
337 {
338     FILE *inf;
339     int block_size;
340     char path[256];
341     MFile mf;
342     CFile cf;
343     int first_time;
344
345     assert (bfs->commit_area);
346     if (!(inf = open_cache (bfs, "rb")))
347     {
348         yaz_log (YLOG_LOG, "No commit file");
349         return ;
350     }
351     while (fscanf (inf, "%s %d", path, &block_size) == 2)
352     {
353         mf = mf_open (bfs->register_area, path, block_size, 1);
354         cf = cf_open (mf, bfs->commit_area, path, block_size, 0, &first_time);
355
356         cf_commit (cf);
357
358         cf_close (cf);
359         mf_close (mf);
360     }
361     fclose (inf);
362 }
363
364 void bf_commitClean (BFiles bfs, const char *spec)
365 {
366     FILE *inf;
367     int block_size;
368     char path[256];
369     MFile mf;
370     CFile cf;
371     int mustDisable = 0;
372     int firstTime;
373
374     if (!bfs->commit_area)
375     {
376         bf_cache (bfs, spec);
377         mustDisable = 1;
378     }
379
380     if (!(inf = open_cache (bfs, "rb")))
381         return ;
382     while (fscanf (inf, "%s %d", path, &block_size) == 2)
383     {
384         mf = mf_open (bfs->register_area, path, block_size, 0);
385         cf = cf_open (mf, bfs->commit_area, path, block_size, 1, &firstTime);
386         cf_unlink (cf);
387         cf_close (cf);
388         mf_close (mf);
389     }
390     fclose (inf);
391     unlink_cache (bfs);
392     if (mustDisable)
393         bf_cache (bfs, 0);
394 }
395
396 int bf_alloc(BFile bf, int no, zint *blocks)
397 {
398     int i;
399     assert(bf->alloc_buf);
400     bf->header_dirty = 1;
401     for (i = 0; i < no; i++)
402     {
403         if (!bf->free_list)
404             blocks[i] = bf->last_block++;
405         else
406         {
407             char buf[16];
408             const char *cp = buf;
409             memset(buf, '\0', sizeof(buf));
410
411             blocks[i] = bf->free_list;
412             if (!bf_read(bf, bf->free_list, 0, sizeof(buf), buf))
413             {
414                 yaz_log(YLOG_WARN, "Bad freelist entry " ZINT_FORMAT,
415                         bf->free_list);
416                 exit(1);
417             }
418             zebra_zint_decode(&cp, &bf->free_list);
419         }
420     }
421     return 0;
422 }
423
424 int bf_free(BFile bf, int no, const zint *blocks)
425 {
426     int i;
427     assert(bf->alloc_buf);
428     bf->header_dirty = 1;
429     for (i = 0; i < no; i++)
430     {
431         char buf[16];
432         char *cp = buf;
433         memset(buf, '\0', sizeof(buf));
434         zebra_zint_encode(&cp, bf->free_list);
435         bf->free_list = blocks[i];
436         bf_write(bf, bf->free_list, 0, sizeof(buf), buf);
437     }
438     return 0;
439 }
440
441 int bfs_register_directory_stat(BFiles bfs, int no, const char **directory,
442                                 double *used_bytes, double *max_bytes)
443 {
444     return mf_area_directory_stat(bfs->register_area, no, directory,
445                                   used_bytes, max_bytes);
446 }
447
448
449 int bfs_shadow_directory_stat(BFiles bfs, int no, const char **directory,
450                               double *used_bytes, double *max_bytes)
451 {
452     if (!bfs->commit_area)
453         return 0;
454     return mf_area_directory_stat(bfs->commit_area, no, directory,
455                                   used_bytes, max_bytes);
456 }
457 /*
458  * Local variables:
459  * c-basic-offset: 4
460  * indent-tabs-mode: nil
461  * End:
462  * vim: shiftwidth=4 tabstop=8 expandtab
463  */
464