1 #define _POSIX_C_SOURCE 200809L
21 char *path; /* path to package file */
25 time_t installed; /* install time, 0 for not installed */
35 char *hash; /* could be fixed length */
37 struct zpm_file *next; /* so you can make a linked list */
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 */
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 */
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
59 int zpm_import(struct zpm *zp, char *path, uint32_t flags, uint8_t *hash);
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);
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);
70 /* export hash to dest */
71 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode);
73 /* export path to dest */
74 int zpm_export(struct zpm *zp, char *path, uint32_t flags, char *dest);
76 int zpm_close(struct zpm *zp);
78 /* attach a signature to a package */
79 int zpm_sign(struct zpm *z, size_t s, void *signature);
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);
85 /* get file information */
86 int zpm_stat(struct zpm *z, struct zpm_file *f, int n);
88 /* will also set the package context to the new package */
89 int zpm_newpkg(struct zpm *z, char *base, char *version, int release);
92 int zpm_begin(struct zpm *z);
93 int zpm_commit(struct zpm *z);
94 int zpm_rollback(struct zpm *z);
96 /* higher level operations */
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);
104 /* slurp up the actual blobs */
105 /* what about versioning them if they change */
106 int zpm_preserve(struct zpm *local);
108 /* check file integrity */
109 int zpm_checkinstall(struct zpm *local);
111 int zpm_merge(struct zpm *z, struct zpm *src, uint32_t flags);
113 void uncompresslzma(void *buf, size_t bufsize, FILE *out);
114 #define SQLERROR(x) fprintf(stderr, "%s %d: %s\n", __func__, __LINE__, (x))
117 static char *dupstr(char *s) {
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 (?,?,?)";
135 rc = sqlite3_prepare(db, sql, -1, &ifile,0);
136 if (rc != SQLITE_OK) {
137 SQLERROR(sqlite3_errmsg(db));
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");
147 sqlite3_bind_text(ifile, 2, version, strlen(version), SQLITE_STATIC);
148 sqlite3_bind_int(ifile, 3, release)
150 rc = sqlite3_step(ifile);
152 if (rc != SQLITE_DONE) {
153 SQLERROR(sqlite3_errmsg(db));
154 sqlite3_finalize(ifile);
157 sqlite3_finalize(ifile);
158 z->pkg = dupstr(base);
159 z->version = dupstr(version);
160 z->release = release;
164 int zpm_begin(struct zpm *z) {
166 sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
168 fprintf(stderr, "sqlite begin error: %s\n", errstr);
169 sqlite3_free(errstr);
175 int zpm_commit(struct zpm *z) {
177 sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
179 fprintf(stderr, "sqlite commit error: %s\n", errstr);
180 sqlite3_free(errstr);
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);
191 int zpm_rollback(struct zpm *z) {
193 sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
195 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
196 sqlite3_free(errstr);
202 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
208 case 1: sql = "pragma application_id = ?;"; break;
209 case 2: sql = "pragma user_version = ?;"; break;
210 default: return -1; break;
213 rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
215 if (rc != SQLITE_OK) {
216 SQLERROR(sqlite3_errmsg(db->db));
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");
227 rc = sqlite3_step(s);
228 if (rc != SQLITE_DONE) {
229 SQLERROR(sqlite3_errmsg(db->db));
230 fprintf(stderr, "cant set pragma\n");
239 int zpm_db_pragma(struct zpm *db, int pragma) {
246 case 1: sql = "pragma application_id;"; break;
247 case 2: sql = "pragma user_version;"; break;
248 default: return -1; break;
251 rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
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? */
260 rc = sqlite3_step(s);
261 if (rc == SQLITE_ROW) {
262 value = sqlite3_column_int(s, 0);
272 int zpm_db_initialize(struct zpm *pkg) {
273 //fprintf(stderr, "initializing zpm database\n");
275 switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
276 case SQLITE_OK: break;
278 SQLERROR(sqlite3_errmsg(pkg->db));
279 fprintf(stderr, "error: %s\n", error);
288 int zpm_open(struct zpm *pkg, char *path) {
301 rc = sqlite3_open(path, &db);
303 SQLERROR(sqlite3_errmsg(db));
308 pkg->path = dupstr(path);
310 appid = zpm_db_pragma(pkg, 1);
311 dbver = zpm_db_pragma(pkg, 2);
313 //fprintf(stderr, "db appid = %x, dbver = %d\n", appid, dbver);
315 case 0: if (!zpm_db_initialize(pkg)) {
320 case 0x5a504442: break;
322 fprintf(stderr, "unknown database type\n");
328 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
333 sqlite3_exec(pkg->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
335 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
336 sqlite3_free(errstr);
342 /* TODO if this is a new database, create structures */
344 /* get a package. what if more than one? what if none? */
348 int zpm_close(struct zpm *pkg) {
350 sqlite3_close(pkg->db);
353 /* TODO free any malloced names and such */
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 */
363 return zpm_vercmp(a, b);
366 int zpm_addvercmp(struct zpm *pkg) {
367 return sqlite3_create_collation(
368 pkg->db, "vercmp", SQLITE_UTF8, NULL,
373 /* set package struct variables, database, environment, then command line */
374 int zpm_readopts(struct zpm *pkg, int ac, char **av) {
381 ev = getenv("ZPMPACKAGE");
383 pkg->pkgname = dupstr(ev);
385 ev = getenv("ZPMPKGREL");
387 pkg->release = strtol(ev, 0, 0);
389 ev = getenv("ZPMPKGVER");
391 pkg->version = dupstr(ev);
394 /* now, parse the options, return optind so the caller can adjust if needed */
399 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
409 /* TODO check null */
410 sqlite3 *db = pkg->db;
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));
420 sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
422 rc = sqlite3_step(ifile);
424 if (rc == SQLITE_DONE) {
425 /* didn't find a row */
426 sqlite3_finalize(ifile);
428 fprintf(stderr, "no such hash\n");
431 /* either way we're done with this now */
433 if (rc != SQLITE_ROW) {
434 SQLERROR(sqlite3_errmsg(db));
435 sqlite3_finalize(ifile);
440 type = sqlite3_column_type(ifile, 0);
441 if (type == SQLITE_NULL) {
442 fprintf(stderr, "no file size\n");
443 sqlite3_finalize(ifile);
447 type = sqlite3_column_type(ifile, 1);
448 if (type == SQLITE_NULL) {
449 fprintf(stderr, "no file data\n");
450 sqlite3_finalize(ifile);
454 //size = sqlite3_column_int64(ifile, 0);
455 xzdata = (void *)sqlite3_column_blob(ifile, 1);
456 blobsize = sqlite3_column_bytes(ifile, 1);
458 if (strcmp(path, "-")) {
459 out = fopen(path, "w");
464 fprintf(stderr, "can't open output file %s\n", path);
465 sqlite3_finalize(ifile);
469 //fwrite(xzdata, blobsize, 1, stdout);
471 //fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
472 uncompresslzma(xzdata, blobsize, out);
476 sqlite3_finalize(ifile);
481 /* flags 0, close mmap, flags 1, return mmap fd */
482 int zpm_hash(char *path, char *hash, uint32_t flags) {
488 unsigned char tmp[32];
491 fd = open(path, O_RDONLY);
493 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
496 if (fstat(fd, &sbuf) == -1) {
497 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
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);
507 content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
510 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
516 sha256_process(&md, content, sbuf.st_size);
517 sha256_done(&md, tmp);
519 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
522 munmap(content, sbuf.st_size);
523 return flags ? fd : 1;
526 static sqlite3_stmt *run_for_hash(sqlite3 *db, char *sql, char *hash) {
530 rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
531 if (rc != SQLITE_OK) {
532 SQLERROR(sqlite3_errmsg(db));
538 sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
543 static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) {
544 if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) {
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);
557 rc = sqlite3_step(ifile);
559 if (rc == SQLITE_ROW) {
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++) {
565 r = sqlite3_column_text(ifile, i);
566 fprintf(stderr, ", %s", r);
568 fprintf(stderr, "\n");
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);
578 sqlite3_finalize(ifile);
579 ifile = run_for_hash(db, "delete from elflibraries where file = ?", hash);
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);
589 sqlite3_finalize(ifile);
590 ifile = run_for_hash(db, "delete from elfneeded where file = ?", hash);
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");
600 sqlite3_finalize(ifile);
602 hdr = libelf_header(content);
603 /* if lib, set soname */
604 if (libelf_type(content) == ET_DYN) {
606 Elf64_Shdr *shdr, *dynsect, *dynstrtab = 0;
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) {
613 } else if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) {
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)) {
639 dynname = elf + dyntab->sh_offset;
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");
654 sqlite3_finalize(ifile);
659 /* if exe, set neededs */
660 if (libelf_type(content) == ET_EXEC) {
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);
672 dyn = (Elf64_Dyn *)(elf + dsect->sh_offset);
676 dyn = (Elf64_Dyn *)dsect;
678 dsect = libelf_section(elf, SHT_DYNAMIC);
681 strsect = libelf_section_n(elf, dsect->sh_link);
682 strtab = elf + strsect->sh_offset;
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) {
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");
702 sqlite3_reset(ifile);
706 sqlite3_finalize(ifile);
713 int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
717 unsigned char tmp[32];
720 int haverow = 0,havedata = 0;
728 if (!pkg || !pkg->db || !path) {
732 /* use local if caller didn't pass in room */
737 flags = 0; /* suppress warning, probably use to follow symlinks */
739 fd = open(path, O_RDONLY);
742 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
745 if (fstat(fd, &sbuf) == -1) {
747 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
750 /* not a regular file? */
751 if (!S_ISREG(sbuf.st_mode)) {
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;
762 /* TODO this is ok, just stored differently */
763 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
768 content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
772 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
778 sha256_process(&md, content, sbuf.st_size);
779 sha256_done(&md, tmp);
781 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
784 //fprintf(stderr, "file %s: %s\n", path, hash);
786 /* TODO check null */
787 sqlite3 *db = pkg->db;
789 /* prepare and bind */
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);
800 sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
802 rc = sqlite3_step(ifile);
804 if (rc != SQLITE_DONE) {
805 if (rc != SQLITE_ROW) {
806 /* didn't find a row */
807 SQLERROR(sqlite3_errmsg(db));
809 munmap(content, sbuf.st_size);
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);
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);
829 /* which is fine, just need to update the row then */
831 havedata = sqlite3_column_int(ifile, 1);
834 sqlite3_finalize(ifile);
838 outbuf = compresslzma(content, sbuf.st_size, &outlen);
840 fprintf(stderr, "compresslzma failed\n");
841 munmap(content, sbuf.st_size);
844 //fprintf(stderr, "compressed to %zu\n", outlen);
846 /* start a transaction */
847 // do that outside of here
852 //fprintf(stderr, "adding file data\n");
853 rc = sqlite3_prepare(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
855 //fprintf(stderr, "creating new data row\n");
856 rc = sqlite3_prepare(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
858 if (rc != SQLITE_OK) {
859 SQLERROR(sqlite3_errmsg(db));
860 fprintf(stderr, "cant prepare data\n");
862 munmap(content, sbuf.st_size);
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");
871 munmap(content, sbuf.st_size);
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");
879 munmap(content, sbuf.st_size);
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");
887 munmap(content, sbuf.st_size);
890 rc = sqlite3_step(ifile);
891 if (rc != SQLITE_DONE) {
892 SQLERROR(sqlite3_errmsg(db));
893 sqlite3_finalize(ifile);
895 munmap(content, sbuf.st_size);
898 sqlite3_finalize(ifile);
903 /* don't need the original file now */
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);
913 munmap(content, sbuf.st_size);
915 /* if package and not nopackage flag, add to package */
916 if (pkg->pkgname && (!ZPM_NOPACKAGE)) {
926 int main(int ac, char **av){
941 fprintf(stderr, "usage: db hash file\n");
945 rc = sqlite3_open(av[1], &db);
947 SQLERROR(sqlite3_errmsg(db));
956 Packages are sqlite databases
958 get application id and userver
960 Primitive operations:
963 associate path with package
964 associate blob with path?
966 * extract blob to a path
967 compare blob to filesystem path
968 create package with info
972 record elf information about blob
975 sign a package? What are we verifying?