]> pd.if.org Git - zpackage/blob - lib/zpm.c
remove dupstr and readopts
[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         //fprintf(stderr, "initializing zpm database\n");
262         char *error;
263         switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
264                 case SQLITE_OK: break;
265                 default:
266                         SQLERROR(sqlite3_errmsg(pkg->db));
267                         fprintf(stderr, "error: %s\n", error);
268                         sqlite3_free(error);
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 int zpm_init(struct zpm *pkg, char *path) {
327         int rc;
328         sqlite3 *db = 0;
329         int appid;
330
331         zpm_clearmem(pkg);
332
333         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
334         if (rc) {
335                 SQLERROR(sqlite3_errmsg(db));
336                 sqlite3_close(db);
337                 return 0;
338         }
339         pkg->db   = db;
340         pkg->path = strdup(path);
341
342         appid = zpm_db_pragma(pkg, 1);
343
344         switch (appid) {
345                 case 0: if (!zpm_db_initialize(pkg)) {
346                                 sqlite3_close(db);
347                                 return 1;
348                         };
349                         break;
350                 case 0x5a504442:
351                         /* already initialized */
352                         break;
353                 default:
354                         fprintf(stderr, "unknown database type\n");
355                         sqlite3_close(db);
356                         return 0;
357                         break;
358         }
359
360         if (!setupdb(pkg)) {
361                 sqlite3_close(db);
362                 pkg->db = 0;
363                 return 0;
364         }
365
366         return 1;
367 }
368
369 int zpm_open(struct zpm *zpm, char *path) {
370         int rc;
371         sqlite3 *db = 0;
372
373         zpm_clearmem(zpm);
374
375         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL);
376         if (rc) {
377                 SQLERROR(sqlite3_errmsg(db));
378                 sqlite3_close(db);
379                 zpm->error = 1;
380                 fprintf(stderr, "path = %s\n", path);
381                 return 0;
382         }
383         zpm->db   = db;
384         zpm->path = strdup(path);
385
386         if (!setupdb(zpm)) {
387                 sqlite3_close(db);
388                 zpm->db = 0;
389                 zpm->error = 1;
390                 return 0;
391         }
392
393         return 1;
394 }
395
396 int zpm_close(struct zpm *pkg) {
397         if (pkg) {
398                 sqlite3_close(pkg->db);
399                 free(pkg->path);
400         }
401         /* TODO free any malloced names and such */
402         return 1;
403 }
404
405 static int zpm_sqlite_vercmp(void *not_used, int lena, const void *a,
406                 int lenb, const void *b) {
407         /* not sure what the ints are, possibly string lengths */
408         if (not_used != 0) fprintf(stderr, "sqlite vercmp not_used = %p\n",
409                         not_used);
410         if (lena == 0 && lenb > 0) return 1;
411         return zpm_vercmp(a, b);
412 }
413
414 int zpm_addvercmp(struct zpm *pkg) {
415         return sqlite3_create_collation(
416                         pkg->db, "vercmp", SQLITE_UTF8, NULL,
417                         zpm_sqlite_vercmp
418                         );
419 }
420
421 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
422         int rc;
423
424         int blobsize;
425         //int64_t size;
426         void *xzdata;
427         int type;
428         FILE *out;
429         sqlite3_stmt *ifile;
430
431         /* TODO check null */
432         sqlite3 *db = pkg->db;
433
434         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
435         if (rc != SQLITE_OK) {
436                 SQLERROR(sqlite3_errmsg(db));
437                 return 0;
438         }
439
440         /* hash, filename */
441
442         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
443
444         rc = sqlite3_step(ifile);
445
446         if (rc == SQLITE_DONE) {
447                 /* didn't find a row */
448                 sqlite3_finalize(ifile);
449                 sqlite3_close(db);
450                 fprintf(stderr, "no such hash: %s\n", hash);
451                 return 0;
452         }
453         /* either way we're done with this now */
454
455         if (rc != SQLITE_ROW) {
456                 SQLERROR(sqlite3_errmsg(db));
457                 sqlite3_finalize(ifile);
458                 sqlite3_close(db);
459                 return 0;
460         }
461
462         type = sqlite3_column_type(ifile, 0);
463         if (type == SQLITE_NULL) {
464                 fprintf(stderr, "no file size\n");
465                 sqlite3_finalize(ifile);
466                 sqlite3_close(db);
467                 return 0;
468         }
469         type = sqlite3_column_type(ifile, 1);
470         if (type == SQLITE_NULL) {
471                 fprintf(stderr, "no file data\n");
472                 sqlite3_finalize(ifile);
473                 sqlite3_close(db);
474                 return 0;
475         }
476         //size = sqlite3_column_int64(ifile, 0);
477         xzdata = (void *)sqlite3_column_blob(ifile, 1);
478         blobsize = sqlite3_column_bytes(ifile, 1);
479
480         if (strcmp(path, "-")) {
481                 out = fopen(path, "w");
482         } else {
483                 out = stdout;
484         }
485         if (!out) {
486                 fprintf(stderr, "can't open output file %s\n", path);
487                 sqlite3_finalize(ifile);
488                 sqlite3_close(db);
489                 return 0;
490         }
491         //fwrite(xzdata, blobsize, 1, stdout);
492
493         //fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
494         uncompresslzma(xzdata, blobsize, out);
495         fclose(out);
496         chmod(path, mode);
497
498         sqlite3_finalize(ifile);
499
500         return 1;
501 }
502
503 static sqlite3_stmt *run_for_hash(sqlite3 *db, char *sql, char *hash) {
504         int rc;
505         sqlite3_stmt *ifile;
506
507         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
508         if (rc != SQLITE_OK) {
509                 SQLERROR(sqlite3_errmsg(db));
510                 return 0;
511         }
512
513         /* hash, filename */
514
515         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
516
517         return ifile;
518 }
519
520 static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) {
521         if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) {
522                 char *strtab;
523                 Elf64_Dyn *dyn;
524                 int i;
525                 Elf64_Phdr *phdr;
526                 Elf64_Ehdr *hdr;
527                 sqlite3_stmt *ifile;
528                 int rc;
529
530                 /* go ahead and set up elf information now */
531                 /* clear existing for this hash */
532                 ifile = run_for_hash(db, "delete from elfinfo where file = ?", hash);
533                 do {
534                         rc = sqlite3_step(ifile);
535 #if 0
536                         if (rc == SQLITE_ROW) {
537                                 int nc;
538                                 fprintf(stderr, "delete row has %d columns: ", sqlite3_column_count(ifile));
539                                 nc = sqlite3_column_count(ifile);
540                                 for (i = 0; i < nc; i++) {
541                                         char *r;
542                                         r = sqlite3_column_text(ifile, i);
543                                         fprintf(stderr, ", %s", r);
544                                 }
545                                 fprintf(stderr, "\n");
546                         }
547 #endif
548                 } while (rc == SQLITE_ROW);
549                 if (rc != SQLITE_DONE) {
550                         SQLERROR(sqlite3_errmsg(db));
551                         sqlite3_finalize(ifile);
552                         fprintf(stderr, "error clearing elf info: %d\n", rc);
553                         return 0;
554                 }
555                 sqlite3_finalize(ifile);
556                 ifile = run_for_hash(db, "delete from elflibraries where file = ?", hash);
557                 do {
558                         rc = sqlite3_step(ifile);
559                 } while (rc == SQLITE_ROW);
560                 if (rc != SQLITE_DONE) {
561                         SQLERROR(sqlite3_errmsg(db));
562                         sqlite3_finalize(ifile);
563                         fprintf(stderr, "error clearing elf library: %d\n", rc);
564                         return 0;
565                 }
566                 sqlite3_finalize(ifile);
567                 ifile = run_for_hash(db, "delete from elfneeded where file = ?", hash);
568                 do {
569                         rc = sqlite3_step(ifile);
570                 } while (rc == SQLITE_ROW);
571                 if (rc != SQLITE_DONE) {
572                         SQLERROR(sqlite3_errmsg(db));
573                         sqlite3_finalize(ifile);
574                         fprintf(stderr, "error clearing elf needed\n");
575                         return 0;
576                 }
577                 sqlite3_finalize(ifile);
578
579                 hdr = libelf_header(content);
580                 /* if lib, set soname */
581                 if (libelf_type(content) == ET_DYN) {
582                         char *soname = libelf_soname(content);
583                         if (soname) {
584
585                                 sqlite3_prepare_v2(db, "insert into elflibraries (file,soname) values (?,?)",-1, &ifile, 0);
586                                 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
587                                 sqlite3_bind_text(ifile,2,soname,-1,SQLITE_STATIC);
588                                 rc = sqlite3_step(ifile);
589                                 if (rc != SQLITE_DONE) {
590                                         SQLERROR(sqlite3_errmsg(db));
591                                         sqlite3_finalize(ifile);
592                                         fprintf(stderr, "error setting library soname\n");
593                                         return 0;
594                                 }
595                                 sqlite3_finalize(ifile);
596                         } else {
597                                 fprintf(stderr, "can't find soname\n");
598                         }
599                 }
600
601                 /* if exe, set neededs */
602                 if (libelf_type(content) == ET_EXEC) {
603                         Elf64_Shdr *dsect;
604                         char *elf;
605
606                         elf = (char *)content;
607                         /* find program header table */
608                         for (i = 0; i < hdr->e_phnum; i++) {
609                                 phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
610                                 if (phdr->p_type == PT_DYNAMIC) {
611                                         dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
612                                 }
613                         }
614                         dyn = (Elf64_Dyn *)(elf + dsect->sh_offset);
615                         if (!dyn) {
616                                 exit(9);
617                         }
618                         dyn = (Elf64_Dyn *)dsect;
619
620                         dsect = libelf_section(elf, SHT_DYNAMIC);
621                         Elf64_Shdr *strsect;
622
623                         strsect = libelf_section_n(elf, dsect->sh_link);
624                         strtab = elf + strsect->sh_offset;
625
626                         sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
627                         sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
628                         while (dyn->d_tag != DT_NULL) {
629                                 if (dyn->d_tag == DT_NEEDED) {
630                                         char *need;
631                                         int rc;
632
633                                         need = strtab + dyn->d_un.d_val;
634                                         if (strlen(need) == 0) continue;
635                                         sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
636 #if 0
637                                         fprintf(stderr, "%s needs %s\n", hash, need);
638 #endif
639                                         rc = sqlite3_step(ifile);
640                                         if (rc != SQLITE_DONE) {
641                                                 SQLERROR(sqlite3_errmsg(db));
642                                                 sqlite3_finalize(ifile);
643                                                 fprintf(stderr, "error setting needed library\n");
644                                                 return 0;
645                                         }
646                                         sqlite3_reset(ifile);
647                                 }
648                                 dyn++;
649                         }
650                         sqlite3_finalize(ifile);
651                 }
652         }
653         return 1;
654 }
655
656 #if 1
657 int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
658         int fd;
659         void *content;
660         struct stat sbuf;
661         unsigned char tmp[32];
662         struct sha256_state md;
663         sqlite3_stmt *ifile;
664         int haverow = 0,havedata = 0;
665         int j,rc,type;
666         char hashbuf[65];
667
668         /* xz compress it */
669         size_t outlen = 0;
670         void *outbuf;
671
672         if (!zpm || !zpm->db || !path) {
673                 return 0;
674         }
675
676         /* use local if caller didn't pass in room */
677         if (!hash) {
678                 hash = hashbuf;
679         }
680
681         if (flags) {
682                 fprintf(stderr, "zpm_import unused flags = %d\n", flags);
683         }
684         /* mmap the file */
685         fd = open(path, O_RDONLY);
686         if (fd == -1) {
687                 zpm->error = errno;
688                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
689                 return 0;
690         }
691         if (fstat(fd, &sbuf) == -1) {
692                 zpm->error = errno;
693                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
694                 return 0;
695         }
696         /* not a regular file? */
697         if (!S_ISREG(sbuf.st_mode)) {
698                 char *ftype;
699                 switch (sbuf.st_mode & S_IFMT) {
700                         case S_IFSOCK: ftype = "socket"; break;
701                         case S_IFLNK : ftype = "symlink"; break;
702                         case S_IFBLK : ftype = "block device"; break;
703                         case S_IFDIR : ftype = "directory"; break;
704                         case S_IFCHR : ftype = "character device"; break;
705                         case S_IFIFO : ftype = "fifo"; break;
706                         default: ftype = "unknown file type"; break;
707                 }
708                 /* TODO this is ok, just stored differently */
709                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
710                 zpm->error = EINVAL;
711                 return 0;
712         }
713
714         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
715         close(fd);
716         if (!content) {
717                 zpm->error = errno;
718                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
719                 return 0;
720         }
721
722         /* get hash */
723         sha256_init(&md);
724         sha256_process(&md, content, sbuf.st_size);
725         sha256_done(&md, tmp);
726         for (j=0;j<32;j++) {
727                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
728         }
729         hash[64] = 0;
730         //fprintf(stderr, "file %s: %s\n", path, hash);
731
732         /* TODO check null */
733         sqlite3 *db = zpm->db;
734
735         /* prepare and bind */
736
737         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
738         if (rc != SQLITE_OK) {
739                 SQLERROR(sqlite3_errmsg(db));
740                 munmap(content, sbuf.st_size);
741                 return 0;
742         }
743
744         /* hash, filename */
745
746         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
747
748         rc = sqlite3_step(ifile);
749
750         if (rc != SQLITE_DONE) {
751                 if (rc != SQLITE_ROW) {
752                         /* didn't find a row */
753                         SQLERROR(sqlite3_errmsg(db));
754                         zpm_rollback(zpm);
755                 munmap(content, sbuf.st_size);
756                         return 0;
757                 }
758                 haverow = 1;
759 //              fprintf(stderr, "have row for hash\n");
760                 type = sqlite3_column_type(ifile, 0);
761                 if (type == SQLITE_NULL) {
762                         /* TODO assert, this shouldn't be possible? */
763                         fprintf(stderr, "no file size\n");
764                         sqlite3_finalize(ifile);
765                 munmap(content, sbuf.st_size);
766                         return 0;
767                 }
768                 type = sqlite3_column_type(ifile, 1);
769                 if (type == SQLITE_NULL) {
770                         /* TODO assert, this shouldn't be possible? */
771                         fprintf(stderr, "no file data\n");
772                         sqlite3_finalize(ifile);
773                 munmap(content, sbuf.st_size);
774                         return 0;
775                         /* which is fine, just need to update the row then */
776                 }
777                 havedata = sqlite3_column_int(ifile, 1);
778         }
779
780         sqlite3_finalize(ifile);
781
782         if (!havedata) {
783                 /* compress */
784                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
785                 if (!outbuf) {
786                         fprintf(stderr, "compresslzma failed\n");
787                 munmap(content, sbuf.st_size);
788                         return 0;
789                 }
790                 //fprintf(stderr, "compressed to %zu\n", outlen);
791
792                 /* start a transaction */
793                 // do that outside of here 
794                 //zpm_begin(zpm);
795
796                 /* insert */
797                 if (haverow) {
798                         //fprintf(stderr, "adding file data\n");
799                         rc = sqlite3_prepare(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
800                 } else {
801                         //fprintf(stderr, "creating new data row\n");
802                         rc = sqlite3_prepare(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
803                 }
804                 if (rc != SQLITE_OK) {
805                         SQLERROR(sqlite3_errmsg(db));
806                         fprintf(stderr, "cant prepare data\n");
807                         zpm_rollback(zpm);
808                 munmap(content, sbuf.st_size);
809                         return 0;
810                 }
811
812                 sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
813                 if (rc != SQLITE_OK) {
814                         SQLERROR(sqlite3_errmsg(db));
815                         fprintf(stderr, "cant bind size\n");
816                         zpm_rollback(zpm);
817                 munmap(content, sbuf.st_size);
818                         return 0;
819                 }
820                 sqlite3_bind_blob64(ifile, 2, outbuf, (sqlite3_int64)outlen, SQLITE_STATIC);
821                 if (rc != SQLITE_OK) {
822                         SQLERROR(sqlite3_errmsg(db));
823                         fprintf(stderr, "cant bind content\n");
824                         zpm_rollback(zpm);
825                 munmap(content, sbuf.st_size);
826                         return 0;
827                 }
828                 sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
829                 if (rc != SQLITE_OK) {
830                         SQLERROR(sqlite3_errmsg(db));
831                         fprintf(stderr, "cant bind hash\n");
832                         zpm_rollback(zpm);
833                 munmap(content, sbuf.st_size);
834                         return 0;
835                 }
836                 rc = sqlite3_step(ifile);
837                 if (rc != SQLITE_DONE) {
838                         SQLERROR(sqlite3_errmsg(db));
839                         sqlite3_finalize(ifile);
840                         zpm_rollback(zpm);
841                 munmap(content, sbuf.st_size);
842                         return 0;
843                 }
844                 sqlite3_finalize(ifile);
845
846                 /* commit */
847                 //zpm_commit(zpm);
848
849                 /* don't need the original file now */
850
851         }
852
853         if (!set_elf_info(zpm->db, hash, content, sbuf.st_size)) {
854                 fprintf(stderr, "setting elf info failed\n");
855                 munmap(content, sbuf.st_size);
856                 return 0;
857         }
858
859         munmap(content, sbuf.st_size);
860
861         /* if package and not nopackage flag, add to package */
862         if (zpm->current_package->name && (!ZPM_NOPACKAGE)) {
863                 /* TODO */
864         }
865
866         /* return */
867         return 1;
868 }
869 #endif
870
871 #if 0
872 int main(int ac, char **av){
873         sqlite3 *db = 0;
874         int rc;
875
876         int blobsize;
877         int64_t size;
878         void *xzdata;
879         int type;
880         FILE *out;
881         sqlite3_stmt *ifile;
882
883         char *hash;
884         char *filename;
885
886         if (ac < 3) {
887                 fprintf(stderr, "usage: db hash file\n");
888                 return 1;
889         }
890
891         rc = sqlite3_open(av[1], &db);
892         if (rc) {
893                 SQLERROR(sqlite3_errmsg(db));
894                 sqlite3_close(db);
895                 return 1;
896         }
897
898 }
899 #endif
900
901 #if 0
902 Packages are sqlite databases
903
904 get application id and userver
905
906 Primitive operations:
907
908 add path to repo
909 associate path with package
910 associate blob with path?
911 add blob to repo
912 * extract blob to a path
913 compare blob to filesystem path
914 create package with info
915
916 Extra primitives:
917
918 record elf information about blob
919 compress blob
920 uncompress blob
921 sign a package?  What are we verifying?
922 #endif