]> pd.if.org Git - zpackage/blob - lib/zpm.c
fix bug in aging view, add man pages
[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         int rv;
311         char *bufa, *bufb;
312
313         if (not_used != 0) fprintf(stderr, "sqlite vercmp not_used = %p\n",
314                         not_used);
315         if (lena == 0 && lenb > 0) return 1;
316         if (lenb == 0 && lena > 0) return -1;
317
318         bufa = sqlite3_malloc(lena+1);
319         bufb = sqlite3_malloc(lenb+1);
320
321         strncpy(bufa, a, lena);
322         strncpy(bufb, b, lenb);
323         bufa[lena] = 0;
324         bufb[lenb] = 0;
325
326         rv = zpm_vercmp(bufa, bufb);
327         sqlite3_free(bufa);
328         sqlite3_free(bufb);
329         return rv;
330 }
331
332 int zpm_addvercmp(struct zpm *pkg) {
333         return sqlite3_create_collation(
334                         pkg->db, "vercmp", SQLITE_UTF8, NULL,
335                         zpm_sqlite_vercmp
336                         );
337 }
338
339 int zpm_extract(struct zpm *pkg, char *hash, char *path, mode_t mode) {
340         int rc;
341         int blobsize;
342         void *xzdata;
343         int type;
344         int out;
345         sqlite3_stmt *ifile;
346         size_t len;
347         char *tmpfile = 0;
348         sqlite3 *db;
349
350         if (!pkg || !pkg->db) {
351                 return 0;
352         }
353         db = pkg->db;
354
355         if (!path) {
356                 path = "-";
357         }
358
359         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
360         if (rc != SQLITE_OK) {
361                 SQLERROR(sqlite3_errmsg(db));
362                 return 0;
363         }
364
365         /* hash, filename */
366
367         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
368
369         rc = sqlite3_step(ifile);
370
371         if (rc == SQLITE_DONE) {
372                 /* didn't find a row */
373                 sqlite3_finalize(ifile);
374                 sqlite3_close(db);
375                 fprintf(stderr, "no such hash: %s\n", hash);
376                 return 0;
377         }
378         /* either way we're done with this now */
379
380         if (rc != SQLITE_ROW) {
381                 SQLERROR(sqlite3_errmsg(db));
382                 sqlite3_finalize(ifile);
383                 sqlite3_close(db);
384                 return 0;
385         }
386
387         type = sqlite3_column_type(ifile, 0);
388         if (type == SQLITE_NULL) {
389                 fprintf(stderr, "no file size\n");
390                 sqlite3_finalize(ifile);
391                 sqlite3_close(db);
392                 return 0;
393         }
394         type = sqlite3_column_type(ifile, 1);
395         if (type == SQLITE_NULL) {
396                 fprintf(stderr, "no file data\n");
397                 sqlite3_finalize(ifile);
398                 sqlite3_close(db);
399                 return 0;
400         }
401         //size = sqlite3_column_int64(ifile, 0);
402         xzdata = (void *)sqlite3_column_blob(ifile, 1);
403         blobsize = sqlite3_column_bytes(ifile, 1);
404
405         if (strcmp(path, "-")) {
406                 len = strlen(path);
407                 tmpfile = malloc(len+8+1);
408                 if (!tmpfile) {
409                         fprintf(stderr, "malloc error\n");
410                         return 0;
411                 }
412                 sprintf(tmpfile, "%sXXXXXX", path);
413
414                 out = open(tmpfile, O_CREAT|O_WRONLY|O_TRUNC, 0600);
415                 if (out == -1) {
416                         fprintf(stderr, "can't open output file %s: %s\n",
417                                         tmpfile, strerror(errno));
418                         sqlite3_finalize(ifile);
419                         sqlite3_close(db);
420                         free(tmpfile);
421                         return 0;
422                 }
423         } else {
424                 out = 1;
425         }
426
427 #if 0
428         fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
429 #endif
430         uncompresslzma(xzdata, blobsize, out);
431         close(out);
432         sqlite3_finalize(ifile);
433
434         rc = 1;
435         if (tmpfile) {
436                 if (chmod(tmpfile, mode) == -1) {
437                         fprintf(stderr, "can't chmod %s: %s\n", tmpfile,
438                                         strerror(errno));
439                         rc = 0;
440                 } else if (rename(tmpfile, path) == -1) {
441                         fprintf(stderr, "extract rename failed: %s\n",
442                                         strerror(errno));
443                         rc = 0;
444                 }
445         }
446
447         if (rc == 0 && tmpfile) {
448                 if (unlink(tmpfile) == -1) {
449                         fprintf(stderr, "unlink tmpfile %s fail: %s\n",
450                                         tmpfile,
451                                         strerror(errno));
452                 }
453         }
454
455         free(tmpfile);
456         return rc;
457 }
458
459 static int run_for_hash(sqlite3 *db, char *sql, char *hash) {
460         int rc;
461         sqlite3_stmt *ifile;
462
463         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
464         if (rc != SQLITE_OK) {
465                 SQLERROR(sqlite3_errmsg(db));
466                 return 0;
467         }
468
469         /* hash, filename */
470
471         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
472         do {
473                 rc = sqlite3_step(ifile);
474         } while (rc == SQLITE_ROW);
475
476         sqlite3_finalize(ifile);
477
478         return rc == SQLITE_DONE;
479 }
480
481 #define SQLERP(db, msg) fprintf(stderr, "%s: %s\n", msg, sqlite3_errmsg(db))
482
483 static int set_elf_info(struct zpm *zpm, char *hash, char *content,
484                 size_t length) {
485
486         char *strtab;
487         Elf64_Dyn *dyn;
488         int i;
489         Elf64_Phdr *phdr;
490         Elf64_Ehdr *hdr;
491         sqlite3_stmt *ifile;
492         sqlite3 *db = zpm->db;
493
494         if (length < sizeof (Elf64_Ehdr) || !libelf_iself(content)) {
495                 /* not an elf file */
496                 return 1;
497         }
498
499         /* clear existing for this hash */
500
501         if (!run_for_hash(db, "delete from elflibraries where file = ?", hash)) {
502                 SQLERP(db, "error clearing elf library");
503                 return 0;
504         }
505
506         if (!run_for_hash(db, "delete from elfneeded where file = ?", hash)) {
507                 SQLERP(db, "error clearing elf needed");
508                 return 0;
509         }
510
511         hdr = libelf_header(content);
512         /* if lib, set soname */
513         if (libelf_type(content) == ET_DYN) {
514                 char *soname = libelf_soname(content);
515                 if (soname) {
516                         zpm_db_run(zpm, "insert into elflibraries (file,soname) values (%Q,%Q);", hash, soname);
517                         if (zpm->error) {
518                                 return 0;
519                         }
520                 }
521                 /* some dyn don't have an soname, so we don't
522                  * need to warn */
523         }
524
525         /* if exe, set neededs */
526         /* libraries can have neededs too */
527         if (libelf_type(content) == ET_EXEC || libelf_type(content) == ET_DYN) {
528                 Elf64_Shdr *dsect = 0;
529                 char *elf;
530
531                 elf = (char *)content;
532                 /* find program header table */
533                 for (i = 0; i < hdr->e_phnum; i++) {
534                         phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
535                         if (phdr->p_type == PT_DYNAMIC) {
536                                 dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
537                         }
538                 }
539                 if (!dsect) {
540                         /* no dynamic section found */
541                         return 1;
542                 }
543
544                 dyn = (Elf64_Dyn *)dsect;
545
546                 dsect = libelf_section(elf, SHT_DYNAMIC);
547                 Elf64_Shdr *strsect;
548
549                 strsect = libelf_section_n(elf, dsect->sh_link);
550                 strtab = elf + strsect->sh_offset;
551
552                 sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
553                 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
554                 while (dyn->d_tag != DT_NULL) {
555                         if (dyn->d_tag == DT_NEEDED) {
556                                 char *need;
557                                 int rc;
558
559                                 need = strtab + dyn->d_un.d_val;
560                                 if (strlen(need) == 0) continue;
561                                 sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
562 #if 0
563                                 fprintf(stderr, "%s needs %s\n", hash, need);
564 #endif
565                                 rc = sqlite3_step(ifile);
566                                 if (rc != SQLITE_DONE) {
567                                         SQLERP(db, "error setting needed library");
568                                         sqlite3_finalize(ifile);
569                                         return 0;
570                                 }
571                                 sqlite3_reset(ifile);
572                         }
573                         dyn++;
574                 }
575                 sqlite3_finalize(ifile);
576         }
577         return 1;
578 }
579
580 int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
581         int fd;
582         void *content = 0;
583         struct stat sbuf;
584         unsigned char tmp[32];
585         struct sha256_state md;
586         sqlite3_stmt *ifile = 0;
587         int haverow = 0,havedata = 0;
588         int j,rc,type;
589         char hashbuf[65];
590
591         /* xz compress it */
592         size_t outlen = 0;
593         void *outbuf;
594
595         if (!zpm || !zpm->db || !path) {
596                 return 0;
597         }
598
599         /* use local if caller didn't pass in room */
600         if (!hash) {
601                 hash = hashbuf;
602         }
603
604         if (flags) {
605                 fprintf(stderr, "zpm_import unused flags = %d\n", flags);
606         }
607         /* mmap the file */
608         fd = open(path, O_RDONLY);
609         if (fd == -1) {
610                 zpm->error = errno;
611                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
612                 return 0;
613         }
614         if (fstat(fd, &sbuf) == -1) {
615                 zpm->error = errno;
616                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
617                 return 0;
618         }
619         /* not a regular file? */
620         if (!S_ISREG(sbuf.st_mode)) {
621                 char *ftype;
622                 switch (sbuf.st_mode & S_IFMT) {
623                         case S_IFSOCK: ftype = "socket"; break;
624                         case S_IFLNK : ftype = "symlink"; break;
625                         case S_IFBLK : ftype = "block device"; break;
626                         case S_IFDIR : ftype = "directory"; break;
627                         case S_IFCHR : ftype = "character device"; break;
628                         case S_IFIFO : ftype = "fifo"; break;
629                         default: ftype = "unknown file type"; break;
630                 }
631                 /* TODO this is ok, just stored differently */
632                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
633                 zpm->error = EINVAL;
634                 return 0;
635         }
636
637         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
638         close(fd);
639         if (!content) {
640                 zpm->error = errno;
641                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
642                 return 0;
643         }
644
645         /* get hash */
646         sha256_init(&md);
647         sha256_process(&md, content, sbuf.st_size);
648         sha256_done(&md, tmp);
649         for (j=0;j<32;j++) {
650                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
651         }
652         hash[64] = 0;
653
654         /* TODO check null */
655         sqlite3 *db = zpm->db;
656
657         /* prepare and bind */
658
659         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
660         if (rc != SQLITE_OK) {
661                 SQLERROR(sqlite3_errmsg(db));
662                 munmap(content, sbuf.st_size);
663                 return 0;
664         }
665
666         /* hash, filename */
667
668         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
669
670         rc = sqlite3_step(ifile);
671
672         if (rc != SQLITE_DONE) {
673                 if (rc != SQLITE_ROW) {
674                         /* didn't find a row */
675                         SQLERROR(sqlite3_errmsg(db));
676                 munmap(content, sbuf.st_size);
677                         return 0;
678                 }
679                 haverow = 1;
680                 type = sqlite3_column_type(ifile, 0);
681                 if (type == SQLITE_NULL) {
682                         /* TODO assert, this shouldn't be possible? */
683                         fprintf(stderr, "no file size\n");
684                         sqlite3_finalize(ifile);
685                 munmap(content, sbuf.st_size);
686                         return 0;
687                 }
688                 type = sqlite3_column_type(ifile, 1);
689                 if (type == SQLITE_NULL) {
690                         /* TODO assert, this shouldn't be possible? */
691                         fprintf(stderr, "no file data\n");
692                         sqlite3_finalize(ifile);
693                 munmap(content, sbuf.st_size);
694                         return 0;
695                         /* which is fine, just need to update the row then */
696                 }
697                 havedata = sqlite3_column_int(ifile, 1);
698         }
699
700         sqlite3_finalize(ifile);
701
702         if (!havedata) {
703                 /* compress */
704 //              fprintf(stderr, "compressing\n");
705                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
706                 if (!outbuf) {
707                         fprintf(stderr, "compresslzma failed\n");
708                         munmap(content, sbuf.st_size);
709                         return 0;
710                 }
711 ////            fprintf(stderr, "compress finished\n");
712
713                 /* insert */
714                 if (haverow) {
715                         rc = sqlite3_prepare_v2(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
716                 } else {
717                         rc = sqlite3_prepare_v2(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
718                 }
719
720                 if (rc != SQLITE_OK) {
721                         SQLERROR(sqlite3_errmsg(db));
722                         fprintf(stderr, "cant prepare data\n");
723                         munmap(content, sbuf.st_size);
724                         return 0;
725                 }
726
727                 rc = sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
728                 if (rc != SQLITE_OK) {
729                         SQLERROR(sqlite3_errmsg(db));
730                         sqlite3_finalize(ifile);
731                         fprintf(stderr, "cant bind size\n");
732                         munmap(content, sbuf.st_size);
733                         return 0;
734                 }
735
736                 rc = sqlite3_bind_blob64(ifile, 2, outbuf,
737                                 (sqlite3_int64)outlen, SQLITE_STATIC);
738                 if (rc != SQLITE_OK) {
739                         SQLERROR(sqlite3_errmsg(db));
740                         sqlite3_finalize(ifile);
741                         fprintf(stderr, "cant bind content\n");
742                         munmap(content, sbuf.st_size);
743                         return 0;
744                 }
745
746                 rc = sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
747                 if (rc != SQLITE_OK) {
748                         SQLERROR(sqlite3_errmsg(db));
749                         fprintf(stderr, "cant bind hash\n");
750                         sqlite3_finalize(ifile);
751                         munmap(content, sbuf.st_size);
752                         return 0;
753                 }
754
755                 rc = sqlite3_step(ifile);
756                 if (rc != SQLITE_DONE) {
757                         SQLERROR(sqlite3_errmsg(db));
758                         sqlite3_finalize(ifile);
759                         munmap(content, sbuf.st_size);
760                         return 0;
761                 }
762                 sqlite3_finalize(ifile);
763
764                 /* don't need the original file now */
765         }
766
767         if (!set_elf_info(zpm, hash, content, sbuf.st_size)) {
768                 fprintf(stderr, "setting elf info failed\n");
769                 munmap(content, sbuf.st_size);
770                 return 0;
771         }
772
773         munmap(content, sbuf.st_size);
774
775         /* return */
776         return 1;
777 }