]> pd.if.org Git - zpackage/blob - lib/zpm.c
8e0687542c290f49dbdf0298045a0bb67a158cd1
[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 static char *dupstr(char *s) {
118         size_t n;
119         char *d;
120
121         n = strlen(s);
122         d = malloc(n+1);
123         if (d) {
124                 d = strcpy(d, s);
125         }
126         return d;
127 }
128
129 #if 0
130 int zpm_newpkg(struct zpm *z, char *base, char *version, int release) {
131         char *sql = "insert or ignore into packages (package,version,release) values (?,?,?)";
132         int rc;
133         sqlite3_stmt *ifile;
134
135         rc = sqlite3_prepare(db, sql, -1, &ifile,0);
136         if (rc != SQLITE_OK) {
137                 SQLERROR(sqlite3_errmsg(db));
138                 return 0;
139         }
140         rc = sqlite3_bind_text(ifile, 1, base, strlen(base), SQLITE_STATIC);
141         if (rc != SQLITE_OK) {
142                 SQLERROR(sqlite3_errmsg(db));
143                 fprintf(stderr, "cant bind package name\n");
144                 zpm_rollback(pkg);
145                 return 0;
146         }
147         sqlite3_bind_text(ifile, 2, version, strlen(version), SQLITE_STATIC);
148         sqlite3_bind_int(ifile, 3, release)
149
150         rc = sqlite3_step(ifile);
151
152         if (rc != SQLITE_DONE) {
153                 SQLERROR(sqlite3_errmsg(db));
154                 sqlite3_finalize(ifile);
155                 return 0;
156         }
157         sqlite3_finalize(ifile);
158         z->pkg = dupstr(base);
159         z->version = dupstr(version);
160         z->release = release;
161 }
162 #endif
163
164 int zpm_begin(struct zpm *z) {
165         char *errstr = 0;
166         sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
167         if (errstr) {
168                 fprintf(stderr, "sqlite begin error: %s\n", errstr);
169                 sqlite3_free(errstr);
170                 return 0;
171         }
172         return 1;
173 }
174
175 int zpm_commit(struct zpm *z) {
176         char *errstr = 0;
177         sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
178         if (errstr) {
179                 fprintf(stderr, "sqlite commit error: %s\n", errstr);
180                 sqlite3_free(errstr);
181                 return 0;
182         }
183         return 1;
184 }
185
186 /* wrapper for sqlite3_exec */
187 int zpm_exec(struct zpm *z, const char *sql, int(*callback)(void *, int, char **, char**), void *arg, char **errmsg) {
188         return sqlite3_exec(z->db, sql, callback, arg, errmsg);
189 }
190
191 int zpm_rollback(struct zpm *z) {
192         char *errstr = 0;
193         sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
194         if (errstr) {
195                 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
196                 sqlite3_free(errstr);
197                 return 0;
198         }
199         return 1;
200 }
201
202 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
203         int rc;
204         char *sql;
205         sqlite3_stmt *s;
206
207         switch (pragma) {
208                 case 1: sql = "pragma application_id = ?;"; break;
209                 case 2: sql = "pragma user_version = ?;"; break;
210                 default: return -1; break;
211         }
212
213         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
214
215         if (rc != SQLITE_OK) {
216                 SQLERROR(sqlite3_errmsg(db->db));
217                 return -1;
218         }
219
220         sqlite3_bind_int(s, 1, value);
221         if (rc != SQLITE_OK) {
222                 SQLERROR(sqlite3_errmsg(db->db));
223                 fprintf(stderr, "cant bind pragma value\n");
224                 sqlite3_finalize(s);
225                 return -1;
226         }
227         rc = sqlite3_step(s);
228         if (rc != SQLITE_DONE) {
229                 SQLERROR(sqlite3_errmsg(db->db));
230                 fprintf(stderr, "cant set pragma\n");
231                 sqlite3_finalize(s);
232                 return -1;
233         }
234
235         sqlite3_finalize(s);
236         return value;
237 }
238
239 int zpm_db_pragma(struct zpm *db, int pragma) {
240         int rc;
241         int value = -1;
242         char *sql = 0;
243         sqlite3_stmt *s;
244
245         switch (pragma) {
246                 case 1: sql = "pragma application_id;"; break;
247                 case 2: sql = "pragma user_version;"; break;
248                 default: return -1; break;
249         }
250
251         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
252
253         if (rc != SQLITE_OK) {
254                 SQLERROR(sqlite3_errmsg(db->db));
255                 fprintf(stderr, "%s, errnum = %d\n", sqlite3_errmsg(db->db), rc);
256                 /* TODO just abort? */
257                 return -1;
258         }
259
260         rc = sqlite3_step(s);
261         if (rc == SQLITE_ROW) {
262                 value = sqlite3_column_int(s, 0);
263         }
264
265         sqlite3_finalize(s);
266         return value;
267 }
268
269 static
270 #include "newdb.c"
271
272 int zpm_db_initialize(struct zpm *pkg) {
273         //fprintf(stderr, "initializing zpm database\n");
274         char *error;
275         switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
276                 case SQLITE_OK: break;
277                 default:
278                         SQLERROR(sqlite3_errmsg(pkg->db));
279                         fprintf(stderr, "error: %s\n", error);
280                         sqlite3_free(error);
281                         return 0;
282                         break;
283         }
284         return 1;
285 }
286
287 /* NULL?  Create? */
288 int zpm_open(struct zpm *pkg, char *path) {
289         int rc;
290         char *errstr = 0;
291         sqlite3 *db = 0;
292         int appid, dbver;
293
294         pkg->db = 0;
295         pkg->path = 0;
296         pkg->version = 0;
297         pkg->release = 0;
298         pkg->pkgname = 0;
299         pkg->installed = 0;
300
301         rc = sqlite3_open(path, &db);
302         if (rc) {
303                 SQLERROR(sqlite3_errmsg(db));
304                 sqlite3_close(db);
305                 return 0;
306         }
307         pkg->db   = db;
308         pkg->path = dupstr(path);
309
310         appid = zpm_db_pragma(pkg, 1);
311         dbver = zpm_db_pragma(pkg, 2);
312
313         //fprintf(stderr, "db appid = %x, dbver = %d\n", appid, dbver);
314         switch (appid) {
315                 case 0: if (!zpm_db_initialize(pkg)) {
316                                 sqlite3_close(db);
317                                 return 1;
318                         };
319                         break;
320                 case 0x5a504442: break;
321                 default:
322                         fprintf(stderr, "unknown database type\n");
323                         sqlite3_close(db);
324                         return 0;
325                         break;
326         }
327         if (dbver > 1) {
328                 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
329                         sqlite3_close(db);
330                         return 0;
331         }
332
333         sqlite3_exec(pkg->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
334         if (errstr) {
335                 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
336                 sqlite3_free(errstr);
337                 sqlite3_close(db);
338                 return 0;
339         }
340
341
342         /* TODO if this is a new database, create structures */
343
344         /* get a package. what if more than one? what if none? */
345         return 1;
346 }
347
348 int zpm_close(struct zpm *pkg) {
349         if (pkg) {
350                 sqlite3_close(pkg->db);
351                 free(pkg->path);
352         }
353         /* TODO free any malloced names and such */
354         return 1;
355 }
356
357 static int zpm_sqlite_vercmp(void *not_used, int unknown, const void *a,
358                 int unk2, const void *b) {
359         /* not sure what the ints are, possibly string lengths */
360         not_used = 0; /* suppress warning */
361         unknown = 0; /* suppress warning */
362         unk2 = 0;
363         return zpm_vercmp(a, b);
364 }
365
366 int zpm_addvercmp(struct zpm *pkg) {
367         return sqlite3_create_collation(
368                         pkg->db, "vercmp", SQLITE_UTF8, NULL,
369                         zpm_sqlite_vercmp
370                         );
371 }
372
373 /* set package struct variables, database, environment, then command line */
374 int zpm_readopts(struct zpm *pkg, int ac, char **av) {
375         char *ev;
376
377         if (!pkg) {
378                 return -1;
379         }
380
381         ev = getenv("ZPMPACKAGE");
382         if (ev) {
383                 pkg->pkgname = dupstr(ev);
384         }
385         ev = getenv("ZPMPKGREL");
386         if (ev) {
387                 pkg->release = strtol(ev, 0, 0);
388         }
389         ev = getenv("ZPMPKGVER");
390         if (ev) {
391                 pkg->version = dupstr(ev);
392         }
393
394         /* now, parse the options, return optind so the caller can adjust if needed */
395
396         return av ? ac : 1;
397 }
398
399 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
400         int rc;
401
402         int blobsize;
403         //int64_t size;
404         void *xzdata;
405         int type;
406         FILE *out;
407         sqlite3_stmt *ifile;
408
409         /* TODO check null */
410         sqlite3 *db = pkg->db;
411
412         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
413         if (rc != SQLITE_OK) {
414                 SQLERROR(sqlite3_errmsg(db));
415                 return 0;
416         }
417
418         /* hash, filename */
419
420         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
421
422         rc = sqlite3_step(ifile);
423
424         if (rc == SQLITE_DONE) {
425                 /* didn't find a row */
426                 sqlite3_finalize(ifile);
427                 sqlite3_close(db);
428                 fprintf(stderr, "no such hash\n");
429                 return 0;
430         }
431         /* either way we're done with this now */
432
433         if (rc != SQLITE_ROW) {
434                 SQLERROR(sqlite3_errmsg(db));
435                 sqlite3_finalize(ifile);
436                 sqlite3_close(db);
437                 return 0;
438         }
439
440         type = sqlite3_column_type(ifile, 0);
441         if (type == SQLITE_NULL) {
442                 fprintf(stderr, "no file size\n");
443                 sqlite3_finalize(ifile);
444                 sqlite3_close(db);
445                 return 0;
446         }
447         type = sqlite3_column_type(ifile, 1);
448         if (type == SQLITE_NULL) {
449                 fprintf(stderr, "no file data\n");
450                 sqlite3_finalize(ifile);
451                 sqlite3_close(db);
452                 return 0;
453         }
454         //size = sqlite3_column_int64(ifile, 0);
455         xzdata = (void *)sqlite3_column_blob(ifile, 1);
456         blobsize = sqlite3_column_bytes(ifile, 1);
457
458         if (strcmp(path, "-")) {
459                 out = fopen(path, "w");
460         } else {
461                 out = stdout;
462         }
463         if (!out) {
464                 fprintf(stderr, "can't open output file %s\n", path);
465                 sqlite3_finalize(ifile);
466                 sqlite3_close(db);
467                 return 0;
468         }
469         //fwrite(xzdata, blobsize, 1, stdout);
470
471         //fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
472         uncompresslzma(xzdata, blobsize, out);
473         fclose(out);
474         chmod(path, mode);
475
476         sqlite3_finalize(ifile);
477
478         return 1;
479 }
480
481 /* flags 0, close mmap, flags 1, return mmap fd */
482 int zpm_hash(char *path, char *hash, uint32_t flags) {
483         int fd;
484         void *content;
485         struct stat sbuf;
486         hash_state md;
487         int j;
488         unsigned char tmp[32];
489
490         /* mmap the file */
491         fd = open(path, O_RDONLY);
492         if (fd == -1) {
493                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
494                 return 0;
495         }
496         if (fstat(fd, &sbuf) == -1) {
497                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
498                 return 0;
499         }
500         /* not a regular file? */
501         if (!S_ISREG(sbuf.st_mode)) {
502                 /* TODO this is ok, just stored differently */
503                 fprintf(stderr, "%s non-regular files unsupported %s\n", __FUNCTION__, path);
504                 return 0;
505         }
506
507         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
508         close(fd);
509         if (!content) {
510                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
511                 return 0;
512         }
513
514         /* get hash */
515         sha256_init(&md);
516         sha256_process(&md, content, sbuf.st_size);
517         sha256_done(&md, tmp);
518         for (j=0;j<32;j++) {
519                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
520         }
521         hash[64] = 0;
522         munmap(content, sbuf.st_size);
523         return flags ? fd : 1;
524 }
525
526 static sqlite3_stmt *run_for_hash(sqlite3 *db, char *sql, char *hash) {
527         int rc;
528         sqlite3_stmt *ifile;
529
530         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
531         if (rc != SQLITE_OK) {
532                 SQLERROR(sqlite3_errmsg(db));
533                 return 0;
534         }
535
536         /* hash, filename */
537
538         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
539
540         return ifile;
541 }
542
543 static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) {
544         if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) {
545                 char *strtab;
546                 Elf64_Dyn *dyn;
547                 int i;
548                 Elf64_Phdr *phdr;
549                 Elf64_Ehdr *hdr;
550                 sqlite3_stmt *ifile;
551                 int rc;
552
553                 /* go ahead and set up elf information now */
554                 /* clear existing for this hash */
555                 ifile = run_for_hash(db, "delete from elfinfo where file = ?", hash);
556                 do {
557                         rc = sqlite3_step(ifile);
558 #if 0
559                         if (rc == SQLITE_ROW) {
560                                 int nc;
561                                 fprintf(stderr, "delete row has %d columns: ", sqlite3_column_count(ifile));
562                                 nc = sqlite3_column_count(ifile);
563                                 for (i = 0; i < nc; i++) {
564                                         char *r;
565                                         r = sqlite3_column_text(ifile, i);
566                                         fprintf(stderr, ", %s", r);
567                                 }
568                                 fprintf(stderr, "\n");
569                         }
570 #endif
571                 } while (rc == SQLITE_ROW);
572                 if (rc != SQLITE_DONE) {
573                         SQLERROR(sqlite3_errmsg(db));
574                         sqlite3_finalize(ifile);
575                         fprintf(stderr, "error clearing elf info: %d\n", rc);
576                         return 0;
577                 }
578                 sqlite3_finalize(ifile);
579                 ifile = run_for_hash(db, "delete from elflibraries where file = ?", hash);
580                 do {
581                         rc = sqlite3_step(ifile);
582                 } while (rc == SQLITE_ROW);
583                 if (rc != SQLITE_DONE) {
584                         SQLERROR(sqlite3_errmsg(db));
585                         sqlite3_finalize(ifile);
586                         fprintf(stderr, "error clearing elf library: %d\n", rc);
587                         return 0;
588                 }
589                 sqlite3_finalize(ifile);
590                 ifile = run_for_hash(db, "delete from elfneeded where file = ?", hash);
591                 do {
592                         rc = sqlite3_step(ifile);
593                 } while (rc == SQLITE_ROW);
594                 if (rc != SQLITE_DONE) {
595                         SQLERROR(sqlite3_errmsg(db));
596                         sqlite3_finalize(ifile);
597                         fprintf(stderr, "error clearing elf needed\n");
598                         return 0;
599                 }
600                 sqlite3_finalize(ifile);
601
602                 hdr = libelf_header(content);
603                 /* if lib, set soname */
604                 if (libelf_type(content) == ET_DYN) {
605                         char *elf;
606                         Elf64_Shdr *shdr, *dynsect, *dynstrtab = 0;
607
608                         elf = (char *)content;
609                         for (i = 0; i < hdr->e_shnum; i++) {
610                                 shdr = (Elf64_Shdr *)(elf + hdr->e_shoff + i * hdr->e_shentsize);
611                                 if (shdr->sh_type == SHT_DYNAMIC) {
612                                         dynsect = shdr;
613                                 } else if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) {
614                                         dynstrtab = shdr;
615                                 }
616                         }
617                         if (!dynstrtab) {
618                                 exit(8);
619                         }
620                         if (!dynsect) {
621                                 exit(9);
622                         }
623
624                         char *name;
625                         Elf64_Shdr *dyntab;
626                         name = elf + dynstrtab->sh_offset;
627                         for (i = 0; i < hdr->e_shnum; i++) {
628                                 shdr = (Elf64_Shdr *)(elf + hdr->e_shoff + i * hdr->e_shentsize);
629                                 if (shdr->sh_type == SHT_STRTAB && !strcmp(".dynstr", name+shdr->sh_name)) {
630                                         dyntab = shdr;
631                                 }
632                         }
633                         if (!dyntab) {
634                                 exit(10);
635                         }
636
637                         char *dynname;
638                         Elf64_Dyn *dent;
639                         dynname = elf + dyntab->sh_offset;
640
641                         for (dent = (Elf64_Dyn *)(elf + dynsect->sh_offset); dent->d_tag != DT_NULL; dent++) {
642                                 if (dent->d_tag == DT_SONAME) {
643                                         char *soname = dynname + dent->d_un.d_val;
644                                         sqlite3_prepare_v2(db, "insert into elflibraries (file,soname) values (?,?)",-1, &ifile, 0);
645                                         sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
646                                         sqlite3_bind_text(ifile,2,soname,-1,SQLITE_STATIC);
647                                         rc = sqlite3_step(ifile);
648                                         if (rc != SQLITE_DONE) {
649                                                 SQLERROR(sqlite3_errmsg(db));
650                                                 sqlite3_finalize(ifile);
651                                                 fprintf(stderr, "error setting library soname\n");
652                                                 return 0;
653                                         }
654                                         sqlite3_finalize(ifile);
655                                 }
656                         }
657                 }
658
659                 /* if exe, set neededs */
660                 if (libelf_type(content) == ET_EXEC) {
661                         Elf64_Shdr *dsect;
662                         char *elf;
663
664                         elf = (char *)content;
665                         /* find program header table */
666                         for (i = 0; i < hdr->e_phnum; i++) {
667                                 phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
668                                 if (phdr->p_type == PT_DYNAMIC) {
669                                         dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
670                                 }
671                         }
672                         dyn = (Elf64_Dyn *)(elf + dsect->sh_offset);
673                         if (!dyn) {
674                                 exit(9);
675                         }
676                         dyn = (Elf64_Dyn *)dsect;
677
678                         dsect = libelf_section(elf, SHT_DYNAMIC);
679                         Elf64_Shdr *strsect;
680
681                         strsect = libelf_section_n(elf, dsect->sh_link);
682                         strtab = elf + strsect->sh_offset;
683
684                         sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
685                         sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
686                         while (dyn->d_tag != DT_NULL) {
687                                 if (dyn->d_tag == DT_NEEDED) {
688                                         char *need;
689                                         int rc;
690
691                                         need = strtab + dyn->d_un.d_val;
692                                         if (strlen(need) == 0) continue;
693                                         sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
694                                         fprintf(stderr, "%s needs %s\n", hash, need);
695                                         rc = sqlite3_step(ifile);
696                                         if (rc != SQLITE_DONE) {
697                                                 SQLERROR(sqlite3_errmsg(db));
698                                                 sqlite3_finalize(ifile);
699                                                 fprintf(stderr, "error setting needed library\n");
700                                                 return 0;
701                                         }
702                                         sqlite3_reset(ifile);
703                                 }
704                                 dyn++;
705                         }
706                         sqlite3_finalize(ifile);
707                 }
708         }
709         return 1;
710 }
711
712 #if 1
713 int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
714         int fd;
715         void *content;
716         struct stat sbuf;
717         unsigned char tmp[32];
718         hash_state md;
719         sqlite3_stmt *ifile;
720         int haverow = 0,havedata = 0;
721         int j,rc,type;
722         char hashbuf[65];
723
724         /* xz compress it */
725         size_t outlen = 0;
726         void *outbuf;
727
728         if (!pkg || !pkg->db || !path) {
729                 return 0;
730         }
731
732         /* use local if caller didn't pass in room */
733         if (!hash) {
734                 hash = hashbuf;
735         }
736
737         flags = 0; /* suppress warning, probably use to follow symlinks */
738         /* mmap the file */
739         fd = open(path, O_RDONLY);
740         if (fd == -1) {
741                 pkg->error = errno;
742                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
743                 return 0;
744         }
745         if (fstat(fd, &sbuf) == -1) {
746                 pkg->error = errno;
747                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
748                 return 0;
749         }
750         /* not a regular file? */
751         if (!S_ISREG(sbuf.st_mode)) {
752                 char *ftype;
753                 switch (sbuf.st_mode & S_IFMT) {
754                         case S_IFSOCK: ftype = "socket"; break;
755                         case S_IFLNK : ftype = "symlink"; break;
756                         case S_IFBLK : ftype = "block device"; break;
757                         case S_IFDIR : ftype = "directory"; break;
758                         case S_IFCHR : ftype = "character device"; break;
759                         case S_IFIFO : ftype = "fifo"; break;
760                         default: ftype = "unknown file type"; break;
761                 }
762                 /* TODO this is ok, just stored differently */
763                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
764                 pkg->error = EINVAL;
765                 return 0;
766         }
767
768         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
769         close(fd);
770         if (!content) {
771                 pkg->error = errno;
772                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
773                 return 0;
774         }
775
776         /* get hash */
777         sha256_init(&md);
778         sha256_process(&md, content, sbuf.st_size);
779         sha256_done(&md, tmp);
780         for (j=0;j<32;j++) {
781                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
782         }
783         hash[64] = 0;
784         //fprintf(stderr, "file %s: %s\n", path, hash);
785
786         /* TODO check null */
787         sqlite3 *db = pkg->db;
788
789         /* prepare and bind */
790
791         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
792         if (rc != SQLITE_OK) {
793                 SQLERROR(sqlite3_errmsg(db));
794                 munmap(content, sbuf.st_size);
795                 return 0;
796         }
797
798         /* hash, filename */
799
800         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
801
802         rc = sqlite3_step(ifile);
803
804         if (rc != SQLITE_DONE) {
805                 if (rc != SQLITE_ROW) {
806                         /* didn't find a row */
807                         SQLERROR(sqlite3_errmsg(db));
808                         zpm_rollback(pkg);
809                 munmap(content, sbuf.st_size);
810                         return 0;
811                 }
812                 haverow = 1;
813 //              fprintf(stderr, "have row for hash\n");
814                 type = sqlite3_column_type(ifile, 0);
815                 if (type == SQLITE_NULL) {
816                         /* TODO assert, this shouldn't be possible? */
817                         fprintf(stderr, "no file size\n");
818                         sqlite3_finalize(ifile);
819                 munmap(content, sbuf.st_size);
820                         return 0;
821                 }
822                 type = sqlite3_column_type(ifile, 1);
823                 if (type == SQLITE_NULL) {
824                         /* TODO assert, this shouldn't be possible? */
825                         fprintf(stderr, "no file data\n");
826                         sqlite3_finalize(ifile);
827                 munmap(content, sbuf.st_size);
828                         return 0;
829                         /* which is fine, just need to update the row then */
830                 }
831                 havedata = sqlite3_column_int(ifile, 1);
832         }
833
834         sqlite3_finalize(ifile);
835
836         if (!havedata) {
837                 /* compress */
838                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
839                 if (!outbuf) {
840                         fprintf(stderr, "compresslzma failed\n");
841                 munmap(content, sbuf.st_size);
842                         return 0;
843                 }
844                 //fprintf(stderr, "compressed to %zu\n", outlen);
845
846                 /* start a transaction */
847                 // do that outside of here 
848                 //zpm_begin(pkg);
849
850                 /* insert */
851                 if (haverow) {
852                         //fprintf(stderr, "adding file data\n");
853                         rc = sqlite3_prepare(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
854                 } else {
855                         //fprintf(stderr, "creating new data row\n");
856                         rc = sqlite3_prepare(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
857                 }
858                 if (rc != SQLITE_OK) {
859                         SQLERROR(sqlite3_errmsg(db));
860                         fprintf(stderr, "cant prepare data\n");
861                         zpm_rollback(pkg);
862                 munmap(content, sbuf.st_size);
863                         return 0;
864                 }
865
866                 sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
867                 if (rc != SQLITE_OK) {
868                         SQLERROR(sqlite3_errmsg(db));
869                         fprintf(stderr, "cant bind size\n");
870                         zpm_rollback(pkg);
871                 munmap(content, sbuf.st_size);
872                         return 0;
873                 }
874                 sqlite3_bind_blob64(ifile, 2, outbuf, (sqlite3_int64)outlen, SQLITE_STATIC);
875                 if (rc != SQLITE_OK) {
876                         SQLERROR(sqlite3_errmsg(db));
877                         fprintf(stderr, "cant bind content\n");
878                         zpm_rollback(pkg);
879                 munmap(content, sbuf.st_size);
880                         return 0;
881                 }
882                 sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
883                 if (rc != SQLITE_OK) {
884                         SQLERROR(sqlite3_errmsg(db));
885                         fprintf(stderr, "cant bind hash\n");
886                         zpm_rollback(pkg);
887                 munmap(content, sbuf.st_size);
888                         return 0;
889                 }
890                 rc = sqlite3_step(ifile);
891                 if (rc != SQLITE_DONE) {
892                         SQLERROR(sqlite3_errmsg(db));
893                         sqlite3_finalize(ifile);
894                         zpm_rollback(pkg);
895                 munmap(content, sbuf.st_size);
896                         return 0;
897                 }
898                 sqlite3_finalize(ifile);
899
900                 /* commit */
901                 //zpm_commit(pkg);
902
903                 /* don't need the original file now */
904
905         }
906
907         if (!set_elf_info(pkg->db, hash, content, sbuf.st_size)) {
908                 fprintf(stderr, "setting elf info failed\n");
909                 munmap(content, sbuf.st_size);
910                 return 0;
911         }
912
913         munmap(content, sbuf.st_size);
914
915         /* if package and not nopackage flag, add to package */
916         if (pkg->pkgname && (!ZPM_NOPACKAGE)) {
917                 /* TODO */
918         }
919
920         /* return */
921         return 1;
922 }
923 #endif
924
925 #if 0
926 int main(int ac, char **av){
927         sqlite3 *db = 0;
928         int rc;
929
930         int blobsize;
931         int64_t size;
932         void *xzdata;
933         int type;
934         FILE *out;
935         sqlite3_stmt *ifile;
936
937         char *hash;
938         char *filename;
939
940         if (ac < 3) {
941                 fprintf(stderr, "usage: db hash file\n");
942                 return 1;
943         }
944
945         rc = sqlite3_open(av[1], &db);
946         if (rc) {
947                 SQLERROR(sqlite3_errmsg(db));
948                 sqlite3_close(db);
949                 return 1;
950         }
951
952 }
953 #endif
954
955 #if 0
956 Packages are sqlite databases
957
958 get application id and userver
959
960 Primitive operations:
961
962 add path to repo
963 associate path with package
964 associate blob with path?
965 add blob to repo
966 * extract blob to a path
967 compare blob to filesystem path
968 create package with info
969
970 Extra primitives:
971
972 record elf information about blob
973 compress blob
974 uncompress blob
975 sign a package?  What are we verifying?
976 #endif