]> pd.if.org Git - zpackage/blob - lib/zpm.c
fix possible memory leak in uncompress
[zpackage] / lib / zpm.c
1 #define _POSIX_C_SOURCE 200809L
2
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <sys/mman.h>
9 #include <unistd.h>
10 #include <fcntl.h>
11 #include <errno.h>
12
13 #include "zpm.h"
14 #include "elf.h"
15
16 #include "sha256.h"
17
18 int zpm_begin(struct zpm *z) {
19         char *errstr = 0;
20         sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
21         if (errstr) {
22                 fprintf(stderr, "sqlite begin error: %s\n", errstr);
23                 sqlite3_free(errstr);
24                 return 0;
25         }
26         return 1;
27 }
28
29 int zpm_commit(struct zpm *z) {
30         char *errstr = 0;
31         sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
32         if (errstr) {
33                 fprintf(stderr, "sqlite commit error: %s\n", errstr);
34                 sqlite3_free(errstr);
35                 return 0;
36         }
37         return 1;
38 }
39
40 /* wrapper for sqlite3_exec */
41 int zpm_exec(struct zpm *z, const char *sql, int(*callback)(void *, int, char **, char**), void *arg, char **errmsg) {
42         return sqlite3_exec(z->db, sql, callback, arg, errmsg);
43 }
44
45 int zpm_rollback(struct zpm *z) {
46         char *errstr = 0;
47         sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
48         if (errstr) {
49                 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
50                 sqlite3_free(errstr);
51                 return 0;
52         }
53         return 1;
54 }
55
56 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
57         int rc;
58         char *sql;
59         sqlite3_stmt *s;
60
61         switch (pragma) {
62                 case 1: sql = "pragma application_id = ?;"; break;
63                 case 2: sql = "pragma user_version = ?;"; break;
64                 default: return -1; break;
65         }
66
67         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
68
69         if (rc != SQLITE_OK) {
70                 SQLERROR(sqlite3_errmsg(db->db));
71                 return -1;
72         }
73
74         sqlite3_bind_int(s, 1, value);
75         if (rc != SQLITE_OK) {
76                 SQLERROR(sqlite3_errmsg(db->db));
77                 fprintf(stderr, "cant bind pragma value\n");
78                 sqlite3_finalize(s);
79                 return -1;
80         }
81         rc = sqlite3_step(s);
82         if (rc != SQLITE_DONE) {
83                 SQLERROR(sqlite3_errmsg(db->db));
84                 fprintf(stderr, "cant set pragma\n");
85                 sqlite3_finalize(s);
86                 return -1;
87         }
88
89         sqlite3_finalize(s);
90         return value;
91 }
92
93 int zpm_db_pragma(struct zpm *db, int pragma) {
94         int rc;
95         int value = -1;
96         char *sql = 0;
97         sqlite3_stmt *s;
98
99         switch (pragma) {
100                 case 1: sql = "pragma application_id;"; break;
101                 case 2: sql = "pragma user_version;"; break;
102                 default: return -1; break;
103         }
104
105         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
106
107         if (rc != SQLITE_OK) {
108                 SQLERROR(sqlite3_errmsg(db->db));
109                 fprintf(stderr, "%s, errnum = %d\n", sqlite3_errmsg(db->db), rc);
110                 /* TODO just abort? */
111                 return -1;
112         }
113
114         rc = sqlite3_step(s);
115         if (rc == SQLITE_ROW) {
116                 value = sqlite3_column_int(s, 0);
117         }
118
119         sqlite3_finalize(s);
120         return value;
121 }
122
123 static
124 #include "newdb.c"
125
126 int zpm_db_initialize(struct zpm *pkg) {
127         char *error;
128         switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
129                 case SQLITE_OK: break;
130                 default:
131                         SQLERROR(sqlite3_errmsg(pkg->db));
132                         fprintf(stderr, "error: %s\n", error);
133                         sqlite3_free(error);
134                         zpm_rollback(pkg);
135                         return 0;
136                         break;
137         }
138         return 1;
139 }
140
141
142 /* assumes pkg->db is set */
143 static int setupdb(struct zpm *zpm) {
144         char *errstr = 0;
145         int appid, dbver;
146
147         zpm->error = 0;
148
149         appid = zpm_db_pragma(zpm, 1);
150         dbver = zpm_db_pragma(zpm, 2);
151
152         if (appid != 0x5a504442) {
153                 fprintf(stderr, "unknown database type\n");
154                 zpm->error = 1;
155                 return 0;
156         }
157
158         if (dbver > 1) {
159                 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
160                 zpm->error = 1;
161                 return 0;
162         }
163
164         sqlite3_exec(zpm->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
165
166         if (errstr) {
167                 free(zpm->errmsg);
168                 zpm->errmsg = strdup(errstr);
169                 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
170                 sqlite3_free(errstr);
171                 zpm->error = 1;
172                 return 0;
173         }
174
175         /* TODO add vercmp */
176
177         return 1;
178 }
179
180 struct zpm *zpm_clearmem(struct zpm *zpm) {
181         if (!zpm) {
182                 zpm = malloc(sizeof *zpm);
183         }
184
185         if (zpm) {
186                 *zpm = (struct zpm){0};
187         }
188
189         return zpm;
190 }
191
192 static void zpm_set_db_errmsg(struct zpm *zpm, const char *msg) {
193         if (zpm) {
194                 if (zpm->dberrmsg) {
195                         free(zpm->dberrmsg);
196                 }
197                 if (msg) {
198                         zpm->dberrmsg = strdup(msg);
199                         if (!zpm->dberrmsg) {
200                                 zpm->error = 1;
201                         }
202                 } else {
203                         zpm->dberrmsg = 0;
204                 }
205         }
206 }
207
208 int zpm_init(struct zpm *pkg, char *path) {
209         int rc;
210         sqlite3 *db = 0;
211         int appid;
212
213         if (!pkg) {
214                 return 0;
215         }
216
217         zpm_clearmem(pkg);
218
219         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
220         if (rc) {
221                 pkg->error = 1;
222                 pkg->dbresult = rc;
223                 zpm_set_db_errmsg(pkg, sqlite3_errstr(rc));
224                 if (db) {
225                         sqlite3_close(db);
226                 }
227                 fprintf(stderr, "error (%d): %s: %s\n", rc,
228                                 pkg->dberrmsg ? pkg->dberrmsg : "null", path);
229
230                 return 0;
231         }
232         pkg->db   = db;
233         pkg->path = strdup(path);
234
235         appid = zpm_db_pragma(pkg, 1);
236
237         switch (appid) {
238                 case 0: if (!zpm_db_initialize(pkg)) {
239                                 sqlite3_close(db);
240                                 return 1;
241                         };
242                         break;
243                 case 0x5a504442:
244                         /* already initialized */
245                         break;
246                 default:
247                         fprintf(stderr, "unknown database type\n");
248                         sqlite3_close(db);
249                         return 0;
250                         break;
251         }
252
253         if (!setupdb(pkg)) {
254                 sqlite3_close(db);
255                 pkg->db = 0;
256                 return 0;
257         }
258         zpm_addvercmp(pkg);
259
260         return 1;
261 }
262
263 int zpm_open(struct zpm *zpm, char *path) {
264         int rc;
265         sqlite3 *db = 0;
266
267         zpm_clearmem(zpm);
268
269         if (!path) {
270                 path = getenv("ZPMDB");
271         }
272
273         if (!path) {
274                 path = "/var/lib/zpm/local.db";
275         }
276
277         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL);
278         if (rc) {
279                 SQLERROR(sqlite3_errmsg(db));
280                 sqlite3_close(db);
281                 zpm->error = 1;
282                 fprintf(stderr, "path = %s\n", path);
283                 return 0;
284         }
285         zpm->db   = db;
286         zpm->path = strdup(path);
287
288         if (!setupdb(zpm)) {
289                 sqlite3_close(db);
290                 zpm->db = 0;
291                 zpm->error = 1;
292                 return 0;
293         }
294         zpm_addvercmp(zpm);
295
296         return 1;
297 }
298
299 int zpm_close(struct zpm *pkg) {
300         if (pkg) {
301                 sqlite3_close(pkg->db);
302                 free(pkg->path);
303         }
304         /* TODO free any malloced names and such */
305         return 1;
306 }
307
308 static int zpm_sqlite_vercmp(void *not_used, int lena, const void *a,
309                 int lenb, const void *b) {
310         /* not sure what the ints are, possibly string lengths */
311         if (not_used != 0) fprintf(stderr, "sqlite vercmp not_used = %p\n",
312                         not_used);
313         if (lena == 0 && lenb > 0) return 1;
314         return zpm_vercmp(a, b);
315 }
316
317 int zpm_addvercmp(struct zpm *pkg) {
318         return sqlite3_create_collation(
319                         pkg->db, "vercmp", SQLITE_UTF8, NULL,
320                         zpm_sqlite_vercmp
321                         );
322 }
323
324 int zpm_extract(struct zpm *pkg, char *hash, char *path, mode_t mode) {
325         int rc;
326         int blobsize;
327         void *xzdata;
328         int type;
329         int out;
330         sqlite3_stmt *ifile;
331         size_t len;
332         char *tmpfile = 0;
333         sqlite3 *db;
334
335         if (!pkg || !pkg->db) {
336                 return 0;
337         }
338         db = pkg->db;
339
340         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
341         if (rc != SQLITE_OK) {
342                 SQLERROR(sqlite3_errmsg(db));
343                 return 0;
344         }
345
346         /* hash, filename */
347
348         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
349
350         rc = sqlite3_step(ifile);
351
352         if (rc == SQLITE_DONE) {
353                 /* didn't find a row */
354                 sqlite3_finalize(ifile);
355                 sqlite3_close(db);
356                 fprintf(stderr, "no such hash: %s\n", hash);
357                 return 0;
358         }
359         /* either way we're done with this now */
360
361         if (rc != SQLITE_ROW) {
362                 SQLERROR(sqlite3_errmsg(db));
363                 sqlite3_finalize(ifile);
364                 sqlite3_close(db);
365                 return 0;
366         }
367
368         type = sqlite3_column_type(ifile, 0);
369         if (type == SQLITE_NULL) {
370                 fprintf(stderr, "no file size\n");
371                 sqlite3_finalize(ifile);
372                 sqlite3_close(db);
373                 return 0;
374         }
375         type = sqlite3_column_type(ifile, 1);
376         if (type == SQLITE_NULL) {
377                 fprintf(stderr, "no file data\n");
378                 sqlite3_finalize(ifile);
379                 sqlite3_close(db);
380                 return 0;
381         }
382         //size = sqlite3_column_int64(ifile, 0);
383         xzdata = (void *)sqlite3_column_blob(ifile, 1);
384         blobsize = sqlite3_column_bytes(ifile, 1);
385
386         if (strcmp(path, "-")) {
387                 len = strlen(path);
388                 tmpfile = malloc(len+8+1);
389                 if (!tmpfile) {
390                         fprintf(stderr, "malloc error\n");
391                         return 0;
392                 }
393                 sprintf(tmpfile, "%sXXXXXX", path);
394
395                 out = open(tmpfile, O_CREAT|O_WRONLY|O_TRUNC, 0600);
396                 if (out == -1) {
397                         fprintf(stderr, "can't open output file %s: %s\n",
398                                         tmpfile, strerror(errno));
399                         sqlite3_finalize(ifile);
400                         sqlite3_close(db);
401                         free(tmpfile);
402                         return 0;
403                 }
404         } else {
405                 out = 1;
406         }
407
408 #if 0
409         fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
410 #endif
411         uncompresslzma(xzdata, blobsize, out);
412         close(out);
413         sqlite3_finalize(ifile);
414
415         rc = 1;
416         if (tmpfile) {
417                 if (chmod(tmpfile, mode) == -1) {
418                         fprintf(stderr, "can't chmod %s: %s\n", tmpfile,
419                                         strerror(errno));
420                         rc = 0;
421                 } else if (rename(tmpfile, path) == -1) {
422                         fprintf(stderr, "extract rename failed: %s\n",
423                                         strerror(errno));
424                         rc = 0;
425                 }
426         }
427
428         if (rc == 0 && tmpfile) {
429                 if (unlink(tmpfile) == -1) {
430                         fprintf(stderr, "unlink tmpfile %s fail: %s\n",
431                                         tmpfile,
432                                         strerror(errno));
433                 }
434         }
435
436         free(tmpfile);
437         return rc;
438 }
439
440 static int run_for_hash(sqlite3 *db, char *sql, char *hash) {
441         int rc;
442         sqlite3_stmt *ifile;
443
444         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
445         if (rc != SQLITE_OK) {
446                 SQLERROR(sqlite3_errmsg(db));
447                 return 0;
448         }
449
450         /* hash, filename */
451
452         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
453         do {
454                 rc = sqlite3_step(ifile);
455         } while (rc == SQLITE_ROW);
456
457         sqlite3_finalize(ifile);
458
459         return rc == SQLITE_DONE;
460 }
461
462 #define SQLERP(db, msg) fprintf(stderr, "%s: %s\n", msg, sqlite3_errmsg(db))
463
464 static int set_elf_info(struct zpm *zpm, char *hash, char *content,
465                 size_t length) {
466
467         char *strtab;
468         Elf64_Dyn *dyn;
469         int i;
470         Elf64_Phdr *phdr;
471         Elf64_Ehdr *hdr;
472         sqlite3_stmt *ifile;
473         sqlite3 *db = zpm->db;
474
475         if (length < sizeof (Elf64_Ehdr) || !libelf_iself(content)) {
476                 /* not an elf file */
477                 return 1;
478         }
479
480         /* clear existing for this hash */
481
482         if (!run_for_hash(db, "delete from elflibraries where file = ?", hash)) {
483                 SQLERP(db, "error clearing elf library");
484                 return 0;
485         }
486
487         if (!run_for_hash(db, "delete from elfneeded where file = ?", hash)) {
488                 SQLERP(db, "error clearing elf needed");
489                 return 0;
490         }
491
492         hdr = libelf_header(content);
493         /* if lib, set soname */
494         if (libelf_type(content) == ET_DYN) {
495                 char *soname = libelf_soname(content);
496                 if (soname) {
497                         zpm_db_run(zpm, "insert into elflibraries (file,soname) values (%Q,%Q);", hash, soname);
498                         if (zpm->error) {
499                                 return 0;
500                         }
501                 } else {
502                         fprintf(stderr, "can't find soname\n");
503                 }
504         }
505
506         /* if exe, set neededs */
507         /* libraries can have neededs too */
508         if (libelf_type(content) == ET_EXEC || libelf_type(content) == ET_DYN) {
509                 Elf64_Shdr *dsect = 0;
510                 char *elf;
511
512                 elf = (char *)content;
513                 /* find program header table */
514                 for (i = 0; i < hdr->e_phnum; i++) {
515                         phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
516                         if (phdr->p_type == PT_DYNAMIC) {
517                                 dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
518                         }
519                 }
520                 if (!dsect) {
521                         /* no dynamic section found */
522                         return 1;
523                 }
524
525                 dyn = (Elf64_Dyn *)dsect;
526
527                 dsect = libelf_section(elf, SHT_DYNAMIC);
528                 Elf64_Shdr *strsect;
529
530                 strsect = libelf_section_n(elf, dsect->sh_link);
531                 strtab = elf + strsect->sh_offset;
532
533                 sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
534                 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
535                 while (dyn->d_tag != DT_NULL) {
536                         if (dyn->d_tag == DT_NEEDED) {
537                                 char *need;
538                                 int rc;
539
540                                 need = strtab + dyn->d_un.d_val;
541                                 if (strlen(need) == 0) continue;
542                                 sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
543 #if 0
544                                 fprintf(stderr, "%s needs %s\n", hash, need);
545 #endif
546                                 rc = sqlite3_step(ifile);
547                                 if (rc != SQLITE_DONE) {
548                                         SQLERP(db, "error setting needed library");
549                                         sqlite3_finalize(ifile);
550                                         return 0;
551                                 }
552                                 sqlite3_reset(ifile);
553                         }
554                         dyn++;
555                 }
556                 sqlite3_finalize(ifile);
557         }
558         return 1;
559 }
560
561 int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
562         int fd;
563         void *content = 0;
564         struct stat sbuf;
565         unsigned char tmp[32];
566         struct sha256_state md;
567         sqlite3_stmt *ifile = 0;
568         int haverow = 0,havedata = 0;
569         int j,rc,type;
570         char hashbuf[65];
571
572         /* xz compress it */
573         size_t outlen = 0;
574         void *outbuf;
575
576         if (!zpm || !zpm->db || !path) {
577                 return 0;
578         }
579
580         /* use local if caller didn't pass in room */
581         if (!hash) {
582                 hash = hashbuf;
583         }
584
585         if (flags) {
586                 fprintf(stderr, "zpm_import unused flags = %d\n", flags);
587         }
588         /* mmap the file */
589         fd = open(path, O_RDONLY);
590         if (fd == -1) {
591                 zpm->error = errno;
592                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
593                 return 0;
594         }
595         if (fstat(fd, &sbuf) == -1) {
596                 zpm->error = errno;
597                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
598                 return 0;
599         }
600         /* not a regular file? */
601         if (!S_ISREG(sbuf.st_mode)) {
602                 char *ftype;
603                 switch (sbuf.st_mode & S_IFMT) {
604                         case S_IFSOCK: ftype = "socket"; break;
605                         case S_IFLNK : ftype = "symlink"; break;
606                         case S_IFBLK : ftype = "block device"; break;
607                         case S_IFDIR : ftype = "directory"; break;
608                         case S_IFCHR : ftype = "character device"; break;
609                         case S_IFIFO : ftype = "fifo"; break;
610                         default: ftype = "unknown file type"; break;
611                 }
612                 /* TODO this is ok, just stored differently */
613                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
614                 zpm->error = EINVAL;
615                 return 0;
616         }
617
618         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
619         close(fd);
620         if (!content) {
621                 zpm->error = errno;
622                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
623                 return 0;
624         }
625
626         /* get hash */
627         sha256_init(&md);
628         sha256_process(&md, content, sbuf.st_size);
629         sha256_done(&md, tmp);
630         for (j=0;j<32;j++) {
631                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
632         }
633         hash[64] = 0;
634
635         /* TODO check null */
636         sqlite3 *db = zpm->db;
637
638         /* prepare and bind */
639
640         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
641         if (rc != SQLITE_OK) {
642                 SQLERROR(sqlite3_errmsg(db));
643                 munmap(content, sbuf.st_size);
644                 return 0;
645         }
646
647         /* hash, filename */
648
649         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
650
651         rc = sqlite3_step(ifile);
652
653         if (rc != SQLITE_DONE) {
654                 if (rc != SQLITE_ROW) {
655                         /* didn't find a row */
656                         SQLERROR(sqlite3_errmsg(db));
657                 munmap(content, sbuf.st_size);
658                         return 0;
659                 }
660                 haverow = 1;
661                 type = sqlite3_column_type(ifile, 0);
662                 if (type == SQLITE_NULL) {
663                         /* TODO assert, this shouldn't be possible? */
664                         fprintf(stderr, "no file size\n");
665                         sqlite3_finalize(ifile);
666                 munmap(content, sbuf.st_size);
667                         return 0;
668                 }
669                 type = sqlite3_column_type(ifile, 1);
670                 if (type == SQLITE_NULL) {
671                         /* TODO assert, this shouldn't be possible? */
672                         fprintf(stderr, "no file data\n");
673                         sqlite3_finalize(ifile);
674                 munmap(content, sbuf.st_size);
675                         return 0;
676                         /* which is fine, just need to update the row then */
677                 }
678                 havedata = sqlite3_column_int(ifile, 1);
679         }
680
681         sqlite3_finalize(ifile);
682
683         if (!havedata) {
684                 /* compress */
685 //              fprintf(stderr, "compressing\n");
686                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
687                 if (!outbuf) {
688                         fprintf(stderr, "compresslzma failed\n");
689                         munmap(content, sbuf.st_size);
690                         return 0;
691                 }
692 ////            fprintf(stderr, "compress finished\n");
693
694                 /* insert */
695                 if (haverow) {
696                         rc = sqlite3_prepare_v2(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
697                 } else {
698                         rc = sqlite3_prepare_v2(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
699                 }
700
701                 if (rc != SQLITE_OK) {
702                         SQLERROR(sqlite3_errmsg(db));
703                         fprintf(stderr, "cant prepare data\n");
704                         munmap(content, sbuf.st_size);
705                         return 0;
706                 }
707
708                 rc = sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
709                 if (rc != SQLITE_OK) {
710                         SQLERROR(sqlite3_errmsg(db));
711                         sqlite3_finalize(ifile);
712                         fprintf(stderr, "cant bind size\n");
713                         munmap(content, sbuf.st_size);
714                         return 0;
715                 }
716
717                 rc = sqlite3_bind_blob64(ifile, 2, outbuf,
718                                 (sqlite3_int64)outlen, SQLITE_STATIC);
719                 if (rc != SQLITE_OK) {
720                         SQLERROR(sqlite3_errmsg(db));
721                         sqlite3_finalize(ifile);
722                         fprintf(stderr, "cant bind content\n");
723                         munmap(content, sbuf.st_size);
724                         return 0;
725                 }
726
727                 rc = sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
728                 if (rc != SQLITE_OK) {
729                         SQLERROR(sqlite3_errmsg(db));
730                         fprintf(stderr, "cant bind hash\n");
731                         sqlite3_finalize(ifile);
732                         munmap(content, sbuf.st_size);
733                         return 0;
734                 }
735
736                 rc = sqlite3_step(ifile);
737                 if (rc != SQLITE_DONE) {
738                         SQLERROR(sqlite3_errmsg(db));
739                         sqlite3_finalize(ifile);
740                         munmap(content, sbuf.st_size);
741                         return 0;
742                 }
743                 sqlite3_finalize(ifile);
744
745                 /* don't need the original file now */
746         }
747
748         if (!set_elf_info(zpm, hash, content, sbuf.st_size)) {
749                 fprintf(stderr, "setting elf info failed\n");
750                 munmap(content, sbuf.st_size);
751                 return 0;
752         }
753
754         munmap(content, sbuf.st_size);
755
756         /* return */
757         return 1;
758 }