fix inaccurace memory count
[tedtools.git] / flatdb.c
1 /*
2  * Copyright (c) 2004 Teodor Sigaev <teodor@sigaev.ru>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *        notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *        notice, this list of conditions and the following disclaimer in the
12  *        documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the author nor the names of any co-contributors
14  *        may be used to endorse or promote products derived from this software
15  *        without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <fcntl.h>
32 #include <unistd.h>
33 #include <string.h>
34 #include <errno.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/file.h>
38
39 #include "tlog.h"
40 #include "tmalloc.h"
41
42 #include "flatdb.h"
43
44 static FDBFreeSpace*
45 findFreeSpace(FDB *db, size_t length) {
46         FDBFreeSpace *ptr = db->space;
47         
48         while(ptr && ptr - db->space < db->listcur) {
49                 if ( ptr->length >= length )
50                         return ptr; 
51                 ptr++;
52         }
53
54         return NULL; 
55 }
56
57 static void
58 addFreeSpace(FDB *db, off_t offset, size_t length) {
59         if ( db->listcur >= db->listlen ) {
60                 db->listlen *= 2;
61                 db->space = (FDBFreeSpace*) trealloc( db->space, db->listlen * sizeof(FDBFreeSpace) );
62         }
63
64         db->space[ db->listcur ].offset=offset;
65         db->space[ db->listcur ].length=length;
66
67         db->listcur++;
68 }
69
70 static int
71 cmpFS(const void* a, const void* b) {
72         if ( ((FDBFreeSpace*)a)->offset == ((FDBFreeSpace*)b)->offset )
73                 return 0;
74         return ( ((FDBFreeSpace*)a)->offset > ((FDBFreeSpace*)b)->offset ) ? 1 : -1;
75 }
76
77 void
78 FDBVacuumFreeSpace(FDB *db) {
79         FDBFreeSpace *ptr=db->space+1, *ok=db->space;
80
81         if ( db->listcur < 2 )
82                 return;
83
84         qsort( db->space, db->listcur, sizeof(FDBFreeSpace), cmpFS);
85
86         /* merge spaces */
87         while( ptr - db->space < db->listcur ) {
88                 if ( ok->offset + ok->length == ptr->offset || ptr->length==0 ) {
89                         ok->length += ptr->length;
90                         ptr->length=0;
91                 } else
92                         ok++;
93                 ptr++;
94         }
95
96         /* remove void spaces */
97         ptr = ok = db->space;
98         while( ptr - db->space < db->listcur ) {
99                 if ( ptr->length != 0 ) {
100                         if ( ok != ptr )
101                                 memcpy(ok,ptr,sizeof(FDBFreeSpace));
102                         ok++;
103                 }
104                 ptr++;
105         }
106         db->listcur = ok - db->space;   
107 }
108
109 int 
110 FDBOpen(FDB *db, char *file, int readonly) {
111         FDBHeader header;
112         int rc;
113
114         memset(db, 0, sizeof(FDB));
115
116         if ( readonly ) {
117                 db->readonly=1;
118                 db->fd = open(file, O_RDONLY);
119                 if ( db->fd < 0 ) {
120                         tlog(TL_CRIT,"FDBOpen: open failed: %s",strerror(errno));
121                         return FDB_ERROR;
122                 }
123                 if ( flock( db->fd, LOCK_SH ) < 0 ) {
124                         tlog(TL_CRIT,"FDBOpen: flock failed: %s",strerror(errno));
125                         close(db->fd);
126                         return FDB_ERROR;
127                 } 
128         } else {
129                 db->fd = open(file, O_CREAT | O_RDWR, 0666);
130                 if ( db->fd < 0 ) {
131                         tlog(TL_CRIT,"FDBOpen: open failed: %s",strerror(errno));
132                         return FDB_ERROR;
133                 }
134                 if ( flock( db->fd, LOCK_EX ) < 0 ) {
135                         tlog(TL_CRIT,"FDBOpen: flock failed: %s",strerror(errno));
136                         close(db->fd);
137                         return FDB_ERROR;
138                 } 
139         }
140
141         rc = read(db->fd, &header, sizeof(FDBHeader));
142
143         if ( rc<0 ) {
144                 flock( db->fd, LOCK_UN );
145                 close(db->fd);
146                 tlog(TL_CRIT,"FDBOpen: read failed: %s", strerror(errno));
147                 return FDB_ERROR;
148         } else if ( rc==0 ) {
149                 memset(&header, 0, sizeof(FDBHeader));
150         } else if ( rc != sizeof(FDBHeader) ) {
151                 flock( db->fd, LOCK_UN );
152                 close(db->fd);
153                 tlog(TL_CRIT,"FDBOpen: header fault: %d bytes only", rc);
154                 return FDB_ERROR;
155         } else if ( header.isopened ) {
156                 flock( db->fd, LOCK_UN );
157                 close(db->fd);
158                 tlog(TL_CRIT,"FDBOpen: file wasn't closed correctly");
159                 return FDB_ERROR;
160         }
161                 
162         
163         if ( !db->readonly ) {
164                 if ( header.freespace ) {
165                         db->listlen = db->listcur = (header.lenfreespace / sizeof(FDBFreeSpace));
166                         db->space = (FDBFreeSpace*)tmalloc( header.lenfreespace + sizeof(FDBFreeSpace) );
167                 
168                         if ( lseek(db->fd, header.freespace, SEEK_SET)!=header.freespace || 
169                                         read( db->fd, db->space,  header.lenfreespace ) !=  header.lenfreespace ) {
170                                 flock( db->fd, LOCK_UN );
171                                 close(db->fd);
172                                 tlog(TL_CRIT,"FDBOpen: free space read failed: %s", strerror(errno));
173                                 return FDB_ERROR;
174                         }
175                         FDBVacuumFreeSpace(db);
176                 } else {
177                         db->listlen = 8;
178                         db->space = (FDBFreeSpace*)tmalloc( db->listlen*sizeof(FDBFreeSpace) );
179                 }       
180
181                 header.freespace = 0;
182                 header.lenfreespace = 0;
183                 header.isopened = 1;
184
185                 if ( lseek(db->fd, 0, SEEK_SET)!=0 || 
186                                 write(db->fd, &header, sizeof(FDBHeader)) != sizeof(FDBHeader) || 
187                                 fsync(db->fd) ) {
188                         flock( db->fd, LOCK_UN );
189                         close(db->fd);
190                         if ( db->space ) tfree( db->space );
191                         tlog(TL_CRIT,"FDBOpen: can't modify header: %s", strerror(errno));
192                         return FDB_ERROR;
193                 }
194         }       
195
196         return FDB_OK;
197 }
198
199
200 int
201 FDBClose(FDB *db) {
202         if ( !db->readonly) {
203                 FDBHeader header;
204
205                 memset(&header,0,sizeof(FDBHeader));
206
207                 if ( db->listcur ) {
208                         FDBFreeSpace    *ptr;
209
210                         FDBVacuumFreeSpace(db);
211
212                         header.lenfreespace = sizeof(FDBFreeSpace)*db->listcur;
213
214                         ptr = findFreeSpace( db, header.lenfreespace );
215                 
216                         if ( ptr ) {
217                                 header.freespace = ptr->offset;
218                                 if ( lseek(db->fd, ptr->offset, SEEK_SET) != ptr->offset )
219                                         tlog(TL_CRIT|TL_EXIT,"FDBClose: lseek failed: %s", strerror(errno));
220                         } else {
221                                 if ( (header.freespace = lseek(db->fd, 0, SEEK_END)) < 0 ) 
222                                         tlog(TL_CRIT|TL_EXIT,"FDBClose: lseek failed: %s", strerror(errno));
223                                 header.lenfreespace += sizeof(FDBFreeSpace); 
224                                 addFreeSpace(db, header.freespace, header.lenfreespace); 
225                         }
226
227                         if ( write(db->fd, db->space, header.lenfreespace) != header.lenfreespace )
228                                 tlog(TL_CRIT|TL_EXIT,"FDBClose: write failed: %s", strerror(errno));
229                 }
230
231                 header.isopened=0;
232
233                 if ( lseek(db->fd,0,SEEK_SET)!=0 || 
234                                 write(db->fd, &header, sizeof(FDBHeader)) != sizeof(FDBHeader) || 
235                                 fsync(db->fd))
236                         tlog(TL_CRIT|TL_EXIT,"FDBClose: header write  failed: %s", strerror(errno)); 
237         }
238
239         flock( db->fd, LOCK_UN );
240         close(db->fd);
241
242         if ( db->space )
243                 tfree( db->space );
244
245         return FDB_OK;
246 }
247
248 static int
249 readLen(FDB *db, off_t offset, size_t *size) { 
250         if ( lseek(db->fd,offset,SEEK_SET)!=offset)
251                 return FDB_ERROR;
252         
253         if ( read(db->fd,size,sizeof(size_t)) != sizeof(size_t) )
254                 return FDB_ERROR;
255
256         return FDB_OK;
257 }
258
259
260 int
261 FDBDelete(FDB *db, off_t offset, size_t length) {
262         if ( db->readonly )
263                 return FDB_ERROR;
264
265         if ( length==0 ) 
266                 if ( readLen(db, offset, &length) != FDB_OK )
267                         return FDB_ERROR;
268
269         addFreeSpace(db, offset, PTRALIGN(length));
270
271         return FDB_OK;
272 }
273
274
275 int
276 FDBGet(FDB *db, off_t offset, size_t length, FDBRecord **record) {
277         size_t rc;
278
279         *record=NULL;
280
281         if ( offset < sizeof(FDBHeader) )       
282                 return FDB_ERROR;
283
284         if ( length==0 )
285                 if ( readLen(db, offset, &length) != FDB_OK )
286                         return FDB_ERROR;
287
288         *record = (FDBRecord*)tmalloc( length );
289
290         if ( lseek(db->fd,offset,SEEK_SET)!=offset)
291                 return FDB_ERROR;
292
293         if ( (rc=read(db->fd,*record,length)) != length ) {
294                 (*record)->length = rc;
295                 tlog(TL_CRIT,"FDBGet: read (%d bytes) less than needed (%d bytes): %s", rc, length, strerror(errno));
296                 return FDB_INCORRECT;
297         }
298
299         if ( (*record)->length != length ) {
300                 tlog(TL_ALARM, "FDBGet: wrong length in opts: %d bytes and %d bytes really", length, (*record)->length);
301                 if ( (*record)->length > length ) {
302                         rc = (*record)->length;
303                         tfree( *record );
304                         return FDBGet(db, offset, rc, record);
305                 }
306         } 
307
308         return FDB_OK;
309 }
310          
311                 
312 int 
313 FDBPut(FDB *db, FDBRecord *record, off_t *offset ) {
314         FDBFreeSpace *ptr;
315         size_t  aligned;
316
317         if ( db->readonly )
318                 return FDB_ERROR;
319
320         aligned = PTRALIGN(record->length);
321
322         ptr = findFreeSpace( db, aligned ); 
323         if ( ptr ) {
324                 *offset = ptr->offset;
325                 ptr->length -= record->length;
326                 if ( ptr->length == 0 ) {
327                         if ( (ptr - db->space) + 1 != db->listcur ) 
328                                 memmove(ptr, ptr+1, (db->listcur - (ptr - db->space) + 1) * sizeof(FDBFreeSpace));
329                         db->listcur--; 
330                 } else
331                         ptr->offset += record->length;
332                 if ( lseek(db->fd, *offset, SEEK_SET) != *offset ) 
333                         tlog(TL_CRIT|TL_EXIT,"FDBPut: lseek failed: %s", strerror(errno)); 
334         } else {
335                 if ( (*offset = lseek(db->fd, 0, SEEK_END)) < 0 ) 
336                         tlog(TL_CRIT|TL_EXIT,"FDBPut: lseek failed: %s", strerror(errno)); 
337         }
338
339         if ( write(db->fd, record, record->length) != record->length ) 
340                 tlog(TL_CRIT|TL_EXIT,"FDBPut: write failed: %s", strerror(errno));
341         if ( record->length != aligned ) {
342                 char    buf[] = {0, 0, 0, 0, 0, 0, 0, 0};
343                 if ( write(db->fd, buf, aligned - record->length) != (aligned - record->length) ) 
344                         tlog(TL_CRIT|TL_EXIT,"FDBPut: write failed: %s", strerror(errno));
345         }
346
347         return FDB_OK;
348 }
349
350