]> pd.if.org Git - zpackage/blob - lib/zpm.c
add support for notes
[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 #if 0
19 struct zpm {
20         sqlite3 *db;
21         char *path; /* path to package file */
22         char *version;
23         int release;
24         char *pkgname;
25         time_t installed; /* install time, 0 for not installed */
26 };
27
28 struct zpm_file {
29         char *path;
30         int mode;
31         uint32_t filetype;
32         char *tags;
33         char *owner;
34         char *group;
35         char *hash; /* could be fixed length */
36         time_t mtime;
37         struct zpm_file *next; /* so you can make a linked list */
38 };
39
40 /* NULL?  Create? */
41 /* associate with a package ? if only one?  first? */
42 int zpm_open(struct zpm *pkg, char *path);
43 int zpm_pkgname(char *base, char *version, int release); /* construct a package file name */
44
45 /* flags for preserving mode, owner, etc */
46 /* puts hash of import in hash */
47 /* path can be a hash, with an "INTERNAL" flag, i.e. internally import */
48 #define ZPM_MODE 0x1
49 #define ZPM_OWNER 0x2
50 #define ZPM_MTIME 0x4
51 #define ZPM_INTERNAL 0x8
52 #define ZPM_NOBLOB 0x10
53 /* don't run scripts on install */
54 #define ZPM_NOSCRIPTS 0x10
55 /* don't associate the file with a package, just do a raw insert */
56 /* otherwise, associate it with the current package */
57 #define ZPM_NOPACKAGE 0x20
58
59 int zpm_import(struct zpm *zp, char *path, uint32_t flags, uint8_t *hash);
60
61 /* link and unlink hashes to packages */
62 int zpm_link(struct zpm *pkg, char *path, char *hash, struct zpm_file *fileinfo);
63 int zpm_unlink(struct zpm *pkg, char *path);
64
65 /* tag a file.  relative to "current package" */
66 int zpm_tag(struct zpm *zp, char *path, char *tags);
67 /* should this be broken up into separage functions ? */
68 int zpm_md(struct zpm *zp, char *path, int mode, char *owner, char *group, time_t mtime);
69
70 /* export hash to dest */
71 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode);
72
73 /* export path to dest */
74 int zpm_export(struct zpm *zp, char *path, uint32_t flags, char *dest);
75
76 int zpm_close(struct zpm *zp);
77
78 /* attach a signature to a package */
79 int zpm_sign(struct zpm *z, size_t s, void *signature);
80
81 /* set the package info to the nth package, -1 to return count? */
82 /* further import/exports and such will be relative to this package */
83 int zpm_package(struct zpm *zp, int n);
84
85 /* get file information */
86 int zpm_stat(struct zpm *z, struct zpm_file *f, int n);
87
88 /* will also set the package context to the new package */
89 int zpm_newpkg(struct zpm *z, char *base, char *version, int release);
90
91 /* transactions */
92 int zpm_begin(struct zpm *z);
93 int zpm_commit(struct zpm *z);
94 int zpm_rollback(struct zpm *z);
95
96 /* higher level operations */
97
98 /* install or uninstall the package */
99 /* flag for keeping the blobs in local */
100 /* what about tag filtering */
101 int zpm_install(struct zpm *z, struct zpm *local, uint32_t flags);
102 int zpm_uninstall(struct zpm *local);
103
104 /* slurp up the actual blobs */
105 /* what about versioning them if they change */
106 int zpm_preserve(struct zpm *local);
107
108 /* check file integrity */
109 int zpm_checkinstall(struct zpm *local);
110
111 int zpm_merge(struct zpm *z, struct zpm *src, uint32_t flags);
112
113 void uncompresslzma(void *buf, size_t bufsize, FILE *out);
114 #define SQLERROR(x) fprintf(stderr, "%s %d: %s\n", __func__, __LINE__, (x))
115 #endif
116
117 #if 0
118 int zpm_newpkg(struct zpm *z, char *base, char *version, int release) {
119         char *sql = "insert or ignore into packages (package,version,release) values (?,?,?)";
120         int rc;
121         sqlite3_stmt *ifile;
122
123         rc = sqlite3_prepare(db, sql, -1, &ifile,0);
124         if (rc != SQLITE_OK) {
125                 SQLERROR(sqlite3_errmsg(db));
126                 return 0;
127         }
128         rc = sqlite3_bind_text(ifile, 1, base, strlen(base), SQLITE_STATIC);
129         if (rc != SQLITE_OK) {
130                 SQLERROR(sqlite3_errmsg(db));
131                 fprintf(stderr, "cant bind package name\n");
132                 zpm_rollback(pkg);
133                 return 0;
134         }
135         sqlite3_bind_text(ifile, 2, version, strlen(version), SQLITE_STATIC);
136         sqlite3_bind_int(ifile, 3, release)
137
138         rc = sqlite3_step(ifile);
139
140         if (rc != SQLITE_DONE) {
141                 SQLERROR(sqlite3_errmsg(db));
142                 sqlite3_finalize(ifile);
143                 return 0;
144         }
145         sqlite3_finalize(ifile);
146         z->pkg = dupstr(base);
147         z->version = dupstr(version);
148         z->release = release;
149 }
150 #endif
151
152 int zpm_begin(struct zpm *z) {
153         char *errstr = 0;
154         sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
155         if (errstr) {
156                 fprintf(stderr, "sqlite begin error: %s\n", errstr);
157                 sqlite3_free(errstr);
158                 return 0;
159         }
160         return 1;
161 }
162
163 int zpm_commit(struct zpm *z) {
164         char *errstr = 0;
165         sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
166         if (errstr) {
167                 fprintf(stderr, "sqlite commit error: %s\n", errstr);
168                 sqlite3_free(errstr);
169                 return 0;
170         }
171         return 1;
172 }
173
174 /* wrapper for sqlite3_exec */
175 int zpm_exec(struct zpm *z, const char *sql, int(*callback)(void *, int, char **, char**), void *arg, char **errmsg) {
176         return sqlite3_exec(z->db, sql, callback, arg, errmsg);
177 }
178
179 int zpm_rollback(struct zpm *z) {
180         char *errstr = 0;
181         sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
182         if (errstr) {
183                 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
184                 sqlite3_free(errstr);
185                 return 0;
186         }
187         return 1;
188 }
189
190 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
191         int rc;
192         char *sql;
193         sqlite3_stmt *s;
194
195         switch (pragma) {
196                 case 1: sql = "pragma application_id = ?;"; break;
197                 case 2: sql = "pragma user_version = ?;"; break;
198                 default: return -1; break;
199         }
200
201         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
202
203         if (rc != SQLITE_OK) {
204                 SQLERROR(sqlite3_errmsg(db->db));
205                 return -1;
206         }
207
208         sqlite3_bind_int(s, 1, value);
209         if (rc != SQLITE_OK) {
210                 SQLERROR(sqlite3_errmsg(db->db));
211                 fprintf(stderr, "cant bind pragma value\n");
212                 sqlite3_finalize(s);
213                 return -1;
214         }
215         rc = sqlite3_step(s);
216         if (rc != SQLITE_DONE) {
217                 SQLERROR(sqlite3_errmsg(db->db));
218                 fprintf(stderr, "cant set pragma\n");
219                 sqlite3_finalize(s);
220                 return -1;
221         }
222
223         sqlite3_finalize(s);
224         return value;
225 }
226
227 int zpm_db_pragma(struct zpm *db, int pragma) {
228         int rc;
229         int value = -1;
230         char *sql = 0;
231         sqlite3_stmt *s;
232
233         switch (pragma) {
234                 case 1: sql = "pragma application_id;"; break;
235                 case 2: sql = "pragma user_version;"; break;
236                 default: return -1; break;
237         }
238
239         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
240
241         if (rc != SQLITE_OK) {
242                 SQLERROR(sqlite3_errmsg(db->db));
243                 fprintf(stderr, "%s, errnum = %d\n", sqlite3_errmsg(db->db), rc);
244                 /* TODO just abort? */
245                 return -1;
246         }
247
248         rc = sqlite3_step(s);
249         if (rc == SQLITE_ROW) {
250                 value = sqlite3_column_int(s, 0);
251         }
252
253         sqlite3_finalize(s);
254         return value;
255 }
256
257 static
258 #include "newdb.c"
259
260 int zpm_db_initialize(struct zpm *pkg) {
261         char *error;
262         switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
263                 case SQLITE_OK: break;
264                 default:
265                         SQLERROR(sqlite3_errmsg(pkg->db));
266                         fprintf(stderr, "error: %s\n", error);
267                         sqlite3_free(error);
268                         zpm_rollback(pkg);
269                         return 0;
270                         break;
271         }
272         return 1;
273 }
274
275
276 /* assumes pkg->db is set */
277 static int setupdb(struct zpm *zpm) {
278         char *errstr = 0;
279         int appid, dbver;
280
281         zpm->error = 0;
282
283         appid = zpm_db_pragma(zpm, 1);
284         dbver = zpm_db_pragma(zpm, 2);
285
286         if (appid != 0x5a504442) {
287                 fprintf(stderr, "unknown database type\n");
288                 zpm->error = 1;
289                 return 0;
290         }
291
292         if (dbver > 1) {
293                 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
294                 zpm->error = 1;
295                 return 0;
296         }
297
298         sqlite3_exec(zpm->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
299
300         if (errstr) {
301                 free(zpm->errmsg);
302                 zpm->errmsg = strdup(errstr);
303                 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
304                 sqlite3_free(errstr);
305                 zpm->error = 1;
306                 return 0;
307         }
308
309         /* TODO add vercmp */
310
311         return 1;
312 }
313
314 struct zpm *zpm_clearmem(struct zpm *zpm) {
315         if (!zpm) {
316                 zpm = malloc(sizeof *zpm);
317         }
318
319         if (zpm) {
320                 *zpm = (struct zpm){0};
321         }
322
323         return zpm;
324 }
325
326 static void zpm_set_db_errmsg(struct zpm *zpm, const char *msg) {
327         if (zpm) {
328                 if (zpm->dberrmsg) {
329                         free(zpm->dberrmsg);
330                 }
331                 if (msg) {
332                         zpm->dberrmsg = strdup(msg);
333                         if (!zpm->dberrmsg) {
334                                 zpm->error = 1;
335                         }
336                 } else {
337                         zpm->dberrmsg = 0;
338                 }
339         }
340 }
341
342 int zpm_init(struct zpm *pkg, char *path) {
343         int rc;
344         sqlite3 *db = 0;
345         int appid;
346
347         if (!pkg) {
348                 return 0;
349         }
350
351         zpm_clearmem(pkg);
352
353         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
354         if (rc) {
355                 pkg->error = 1;
356                 pkg->dbresult = rc;
357                 zpm_set_db_errmsg(pkg, sqlite3_errstr(rc));
358                 if (db) {
359                         sqlite3_close(db);
360                 }
361                 fprintf(stderr, "error (%d): %s: %s\n", rc,
362                                 pkg->dberrmsg ? pkg->dberrmsg : "null", path);
363
364                 return 0;
365         }
366         pkg->db   = db;
367         pkg->path = strdup(path);
368
369         appid = zpm_db_pragma(pkg, 1);
370
371         switch (appid) {
372                 case 0: if (!zpm_db_initialize(pkg)) {
373                                 sqlite3_close(db);
374                                 return 1;
375                         };
376                         break;
377                 case 0x5a504442:
378                         /* already initialized */
379                         break;
380                 default:
381                         fprintf(stderr, "unknown database type\n");
382                         sqlite3_close(db);
383                         return 0;
384                         break;
385         }
386
387         if (!setupdb(pkg)) {
388                 sqlite3_close(db);
389                 pkg->db = 0;
390                 return 0;
391         }
392         zpm_addvercmp(pkg);
393
394         return 1;
395 }
396
397 int zpm_open(struct zpm *zpm, char *path) {
398         int rc;
399         sqlite3 *db = 0;
400
401         zpm_clearmem(zpm);
402
403         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL);
404         if (rc) {
405                 SQLERROR(sqlite3_errmsg(db));
406                 sqlite3_close(db);
407                 zpm->error = 1;
408                 fprintf(stderr, "path = %s\n", path);
409                 return 0;
410         }
411         zpm->db   = db;
412         zpm->path = strdup(path);
413
414         if (!setupdb(zpm)) {
415                 sqlite3_close(db);
416                 zpm->db = 0;
417                 zpm->error = 1;
418                 return 0;
419         }
420         zpm_addvercmp(zpm);
421
422         return 1;
423 }
424
425 int zpm_close(struct zpm *pkg) {
426         if (pkg) {
427                 sqlite3_close(pkg->db);
428                 free(pkg->path);
429         }
430         /* TODO free any malloced names and such */
431         return 1;
432 }
433
434 static int zpm_sqlite_vercmp(void *not_used, int lena, const void *a,
435                 int lenb, const void *b) {
436         /* not sure what the ints are, possibly string lengths */
437         if (not_used != 0) fprintf(stderr, "sqlite vercmp not_used = %p\n",
438                         not_used);
439         if (lena == 0 && lenb > 0) return 1;
440         return zpm_vercmp(a, b);
441 }
442
443 int zpm_addvercmp(struct zpm *pkg) {
444         return sqlite3_create_collation(
445                         pkg->db, "vercmp", SQLITE_UTF8, NULL,
446                         zpm_sqlite_vercmp
447                         );
448 }
449
450 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
451         int rc;
452
453         int blobsize;
454         //int64_t size;
455         void *xzdata;
456         int type;
457         FILE *out;
458         sqlite3_stmt *ifile;
459
460         /* TODO check null */
461         sqlite3 *db = pkg->db;
462
463         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -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
473         rc = sqlite3_step(ifile);
474
475         if (rc == SQLITE_DONE) {
476                 /* didn't find a row */
477                 sqlite3_finalize(ifile);
478                 sqlite3_close(db);
479                 fprintf(stderr, "no such hash: %s\n", hash);
480                 return 0;
481         }
482         /* either way we're done with this now */
483
484         if (rc != SQLITE_ROW) {
485                 SQLERROR(sqlite3_errmsg(db));
486                 sqlite3_finalize(ifile);
487                 sqlite3_close(db);
488                 return 0;
489         }
490
491         type = sqlite3_column_type(ifile, 0);
492         if (type == SQLITE_NULL) {
493                 fprintf(stderr, "no file size\n");
494                 sqlite3_finalize(ifile);
495                 sqlite3_close(db);
496                 return 0;
497         }
498         type = sqlite3_column_type(ifile, 1);
499         if (type == SQLITE_NULL) {
500                 fprintf(stderr, "no file data\n");
501                 sqlite3_finalize(ifile);
502                 sqlite3_close(db);
503                 return 0;
504         }
505         //size = sqlite3_column_int64(ifile, 0);
506         xzdata = (void *)sqlite3_column_blob(ifile, 1);
507         blobsize = sqlite3_column_bytes(ifile, 1);
508
509         if (strcmp(path, "-")) {
510                 out = fopen(path, "w");
511         } else {
512                 out = stdout;
513         }
514         if (!out) {
515                 fprintf(stderr, "can't open output file %s\n", path);
516                 sqlite3_finalize(ifile);
517                 sqlite3_close(db);
518                 return 0;
519         }
520         //fwrite(xzdata, blobsize, 1, stdout);
521
522         //fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
523         uncompresslzma(xzdata, blobsize, out);
524         fclose(out);
525         chmod(path, mode);
526
527         sqlite3_finalize(ifile);
528
529         return 1;
530 }
531
532 static int run_for_hash(sqlite3 *db, char *sql, char *hash) {
533         int rc;
534         sqlite3_stmt *ifile;
535
536         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
537         if (rc != SQLITE_OK) {
538                 SQLERROR(sqlite3_errmsg(db));
539                 return 0;
540         }
541
542         /* hash, filename */
543
544         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
545         do {
546                 rc = sqlite3_step(ifile);
547         } while (rc == SQLITE_ROW);
548
549         sqlite3_finalize(ifile);
550
551         return rc == SQLITE_DONE;
552 }
553
554 #define SQLERP(db, msg) fprintf(stderr, "%s: %s\n", msg, sqlite3_errmsg(db))
555
556 static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) {
557         if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) {
558                 char *strtab;
559                 Elf64_Dyn *dyn;
560                 int i;
561                 Elf64_Phdr *phdr;
562                 Elf64_Ehdr *hdr;
563                 sqlite3_stmt *ifile;
564                 int rc;
565
566                 /* clear existing for this hash */
567
568                 if (!run_for_hash(db, "delete from elflibraries where file = ?", hash)) {
569                         SQLERP(db, "error clearing elf library");
570                         return 0;
571                 }
572
573                 if (!run_for_hash(db, "delete from elfneeded where file = ?", hash)) {
574                         SQLERP(db, "error clearing elf needed");
575                         return 0;
576                 }
577
578                 hdr = libelf_header(content);
579                 /* if lib, set soname */
580                 if (libelf_type(content) == ET_DYN) {
581                         char *soname = libelf_soname(content);
582                         if (soname) {
583
584                                 sqlite3_prepare_v2(db, "insert into elflibraries (file,soname) values (?,?)",-1, &ifile, 0);
585                                 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
586                                 sqlite3_bind_text(ifile,2,soname,-1,SQLITE_STATIC);
587                                 rc = sqlite3_step(ifile);
588                                 if (rc != SQLITE_DONE) {
589                                         SQLERROR(sqlite3_errmsg(db));
590                                         sqlite3_finalize(ifile);
591                                         fprintf(stderr, "error setting library soname\n");
592                                         return 0;
593                                 }
594                                 sqlite3_finalize(ifile);
595                         } else {
596                                 fprintf(stderr, "can't find soname\n");
597                         }
598                 }
599
600                 /* if exe, set neededs */
601                 if (libelf_type(content) == ET_EXEC) {
602                         Elf64_Shdr *dsect = 0;
603                         char *elf;
604
605                         elf = (char *)content;
606                         /* find program header table */
607                         for (i = 0; i < hdr->e_phnum; i++) {
608                                 phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
609                                 if (phdr->p_type == PT_DYNAMIC) {
610                                         dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
611                                 }
612                         }
613                         if (!dsect) {
614                                 /* no dynamic section found */
615                                 return 1;
616                         }
617
618 #if 0
619                         dyn = (Elf64_Dyn *)(elf + dsect->sh_offset);
620                         if (!dyn) {
621                                 exit(9);
622                         }
623 #endif
624                         dyn = (Elf64_Dyn *)dsect;
625
626                         dsect = libelf_section(elf, SHT_DYNAMIC);
627                         Elf64_Shdr *strsect;
628
629                         strsect = libelf_section_n(elf, dsect->sh_link);
630                         strtab = elf + strsect->sh_offset;
631
632                         sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
633                         sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
634                         while (dyn->d_tag != DT_NULL) {
635                                 if (dyn->d_tag == DT_NEEDED) {
636                                         char *need;
637                                         int rc;
638
639                                         need = strtab + dyn->d_un.d_val;
640                                         if (strlen(need) == 0) continue;
641                                         sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
642 #if 0
643                                         fprintf(stderr, "%s needs %s\n", hash, need);
644 #endif
645                                         rc = sqlite3_step(ifile);
646                                         if (rc != SQLITE_DONE) {
647                                                 SQLERP(db, "error setting needed library");
648                                                 sqlite3_finalize(ifile);
649                                                 return 0;
650                                         }
651                                         sqlite3_reset(ifile);
652                                 }
653                                 dyn++;
654                         }
655                         sqlite3_finalize(ifile);
656                 }
657         }
658         return 1;
659 }
660
661 int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
662         int fd;
663         void *content = 0;
664         struct stat sbuf;
665         unsigned char tmp[32];
666         struct sha256_state md;
667         sqlite3_stmt *ifile = 0;
668         int haverow = 0,havedata = 0;
669         int j,rc,type;
670         char hashbuf[65];
671
672         /* xz compress it */
673         size_t outlen = 0;
674         void *outbuf;
675
676         if (!zpm || !zpm->db || !path) {
677                 return 0;
678         }
679
680         /* use local if caller didn't pass in room */
681         if (!hash) {
682                 hash = hashbuf;
683         }
684
685         if (flags) {
686                 fprintf(stderr, "zpm_import unused flags = %d\n", flags);
687         }
688         /* mmap the file */
689         fd = open(path, O_RDONLY);
690         if (fd == -1) {
691                 zpm->error = errno;
692                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
693                 return 0;
694         }
695         if (fstat(fd, &sbuf) == -1) {
696                 zpm->error = errno;
697                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
698                 return 0;
699         }
700         /* not a regular file? */
701         if (!S_ISREG(sbuf.st_mode)) {
702                 char *ftype;
703                 switch (sbuf.st_mode & S_IFMT) {
704                         case S_IFSOCK: ftype = "socket"; break;
705                         case S_IFLNK : ftype = "symlink"; break;
706                         case S_IFBLK : ftype = "block device"; break;
707                         case S_IFDIR : ftype = "directory"; break;
708                         case S_IFCHR : ftype = "character device"; break;
709                         case S_IFIFO : ftype = "fifo"; break;
710                         default: ftype = "unknown file type"; break;
711                 }
712                 /* TODO this is ok, just stored differently */
713                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
714                 zpm->error = EINVAL;
715                 return 0;
716         }
717
718         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
719         close(fd);
720         if (!content) {
721                 zpm->error = errno;
722                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
723                 return 0;
724         }
725
726         /* get hash */
727         sha256_init(&md);
728         sha256_process(&md, content, sbuf.st_size);
729         sha256_done(&md, tmp);
730         for (j=0;j<32;j++) {
731                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
732         }
733         hash[64] = 0;
734
735         /* TODO check null */
736         sqlite3 *db = zpm->db;
737
738         /* prepare and bind */
739
740         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
741         if (rc != SQLITE_OK) {
742                 SQLERROR(sqlite3_errmsg(db));
743                 munmap(content, sbuf.st_size);
744                 return 0;
745         }
746
747         /* hash, filename */
748
749         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
750
751         rc = sqlite3_step(ifile);
752
753         if (rc != SQLITE_DONE) {
754                 if (rc != SQLITE_ROW) {
755                         /* didn't find a row */
756                         SQLERROR(sqlite3_errmsg(db));
757                 munmap(content, sbuf.st_size);
758                         return 0;
759                 }
760                 haverow = 1;
761                 type = sqlite3_column_type(ifile, 0);
762                 if (type == SQLITE_NULL) {
763                         /* TODO assert, this shouldn't be possible? */
764                         fprintf(stderr, "no file size\n");
765                         sqlite3_finalize(ifile);
766                 munmap(content, sbuf.st_size);
767                         return 0;
768                 }
769                 type = sqlite3_column_type(ifile, 1);
770                 if (type == SQLITE_NULL) {
771                         /* TODO assert, this shouldn't be possible? */
772                         fprintf(stderr, "no file data\n");
773                         sqlite3_finalize(ifile);
774                 munmap(content, sbuf.st_size);
775                         return 0;
776                         /* which is fine, just need to update the row then */
777                 }
778                 havedata = sqlite3_column_int(ifile, 1);
779         }
780
781         sqlite3_finalize(ifile);
782
783         if (!havedata) {
784                 /* compress */
785                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
786                 if (!outbuf) {
787                         fprintf(stderr, "compresslzma failed\n");
788                         munmap(content, sbuf.st_size);
789                         return 0;
790                 }
791
792                 /* insert */
793                 if (haverow) {
794                         rc = sqlite3_prepare_v2(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
795                 } else {
796                         rc = sqlite3_prepare_v2(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
797                 }
798
799                 if (rc != SQLITE_OK) {
800                         SQLERROR(sqlite3_errmsg(db));
801                         fprintf(stderr, "cant prepare data\n");
802                         munmap(content, sbuf.st_size);
803                         return 0;
804                 }
805
806                 rc = sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
807                 if (rc != SQLITE_OK) {
808                         SQLERROR(sqlite3_errmsg(db));
809                         sqlite3_finalize(ifile);
810                         fprintf(stderr, "cant bind size\n");
811                         munmap(content, sbuf.st_size);
812                         return 0;
813                 }
814
815                 rc = sqlite3_bind_blob64(ifile, 2, outbuf,
816                                 (sqlite3_int64)outlen, SQLITE_STATIC);
817                 if (rc != SQLITE_OK) {
818                         SQLERROR(sqlite3_errmsg(db));
819                         sqlite3_finalize(ifile);
820                         fprintf(stderr, "cant bind content\n");
821                         munmap(content, sbuf.st_size);
822                         return 0;
823                 }
824
825                 rc = sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
826                 if (rc != SQLITE_OK) {
827                         SQLERROR(sqlite3_errmsg(db));
828                         fprintf(stderr, "cant bind hash\n");
829                         sqlite3_finalize(ifile);
830                         munmap(content, sbuf.st_size);
831                         return 0;
832                 }
833
834                 rc = sqlite3_step(ifile);
835                 if (rc != SQLITE_DONE) {
836                         SQLERROR(sqlite3_errmsg(db));
837                         sqlite3_finalize(ifile);
838                         munmap(content, sbuf.st_size);
839                         return 0;
840                 }
841                 sqlite3_finalize(ifile);
842
843                 /* don't need the original file now */
844         }
845
846         if (!set_elf_info(zpm->db, hash, content, sbuf.st_size)) {
847                 fprintf(stderr, "setting elf info failed\n");
848                 munmap(content, sbuf.st_size);
849                 return 0;
850         }
851
852         munmap(content, sbuf.st_size);
853
854         /* return */
855         return 1;
856 }