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))
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 (?,?,?)";
123 rc = sqlite3_prepare(db, sql, -1, &ifile,0);
124 if (rc != SQLITE_OK) {
125 SQLERROR(sqlite3_errmsg(db));
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");
135 sqlite3_bind_text(ifile, 2, version, strlen(version), SQLITE_STATIC);
136 sqlite3_bind_int(ifile, 3, release)
138 rc = sqlite3_step(ifile);
140 if (rc != SQLITE_DONE) {
141 SQLERROR(sqlite3_errmsg(db));
142 sqlite3_finalize(ifile);
145 sqlite3_finalize(ifile);
146 z->pkg = dupstr(base);
147 z->version = dupstr(version);
148 z->release = release;
152 int zpm_begin(struct zpm *z) {
154 sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
156 fprintf(stderr, "sqlite begin error: %s\n", errstr);
157 sqlite3_free(errstr);
163 int zpm_commit(struct zpm *z) {
165 sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
167 fprintf(stderr, "sqlite commit error: %s\n", errstr);
168 sqlite3_free(errstr);
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);
179 int zpm_rollback(struct zpm *z) {
181 sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
183 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
184 sqlite3_free(errstr);
190 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
196 case 1: sql = "pragma application_id = ?;"; break;
197 case 2: sql = "pragma user_version = ?;"; break;
198 default: return -1; break;
201 rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
203 if (rc != SQLITE_OK) {
204 SQLERROR(sqlite3_errmsg(db->db));
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");
215 rc = sqlite3_step(s);
216 if (rc != SQLITE_DONE) {
217 SQLERROR(sqlite3_errmsg(db->db));
218 fprintf(stderr, "cant set pragma\n");
227 int zpm_db_pragma(struct zpm *db, int pragma) {
234 case 1: sql = "pragma application_id;"; break;
235 case 2: sql = "pragma user_version;"; break;
236 default: return -1; break;
239 rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
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? */
248 rc = sqlite3_step(s);
249 if (rc == SQLITE_ROW) {
250 value = sqlite3_column_int(s, 0);
260 int zpm_db_initialize(struct zpm *pkg) {
262 switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
263 case SQLITE_OK: break;
265 SQLERROR(sqlite3_errmsg(pkg->db));
266 fprintf(stderr, "error: %s\n", error);
276 /* assumes pkg->db is set */
277 static int setupdb(struct zpm *zpm) {
283 appid = zpm_db_pragma(zpm, 1);
284 dbver = zpm_db_pragma(zpm, 2);
286 if (appid != 0x5a504442) {
287 fprintf(stderr, "unknown database type\n");
293 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
298 sqlite3_exec(zpm->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
302 zpm->errmsg = strdup(errstr);
303 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
304 sqlite3_free(errstr);
309 /* TODO add vercmp */
314 struct zpm *zpm_clearmem(struct zpm *zpm) {
316 zpm = malloc(sizeof *zpm);
320 *zpm = (struct zpm){0};
326 static void zpm_set_db_errmsg(struct zpm *zpm, const char *msg) {
332 zpm->dberrmsg = strdup(msg);
333 if (!zpm->dberrmsg) {
342 int zpm_init(struct zpm *pkg, char *path) {
353 rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
357 zpm_set_db_errmsg(pkg, sqlite3_errstr(rc));
361 fprintf(stderr, "error (%d): %s: %s\n", rc,
362 pkg->dberrmsg ? pkg->dberrmsg : "null", path);
367 pkg->path = strdup(path);
369 appid = zpm_db_pragma(pkg, 1);
372 case 0: if (!zpm_db_initialize(pkg)) {
378 /* already initialized */
381 fprintf(stderr, "unknown database type\n");
397 int zpm_open(struct zpm *zpm, char *path) {
403 rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL);
405 SQLERROR(sqlite3_errmsg(db));
408 fprintf(stderr, "path = %s\n", path);
412 zpm->path = strdup(path);
425 int zpm_close(struct zpm *pkg) {
427 sqlite3_close(pkg->db);
430 /* TODO free any malloced names and such */
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",
439 if (lena == 0 && lenb > 0) return 1;
440 return zpm_vercmp(a, b);
443 int zpm_addvercmp(struct zpm *pkg) {
444 return sqlite3_create_collation(
445 pkg->db, "vercmp", SQLITE_UTF8, NULL,
450 int zpm_extract(struct zpm *pkg, char *hash, char *path, mode_t mode) {
461 if (!pkg || !pkg->db) {
466 rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
467 if (rc != SQLITE_OK) {
468 SQLERROR(sqlite3_errmsg(db));
474 sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
476 rc = sqlite3_step(ifile);
478 if (rc == SQLITE_DONE) {
479 /* didn't find a row */
480 sqlite3_finalize(ifile);
482 fprintf(stderr, "no such hash: %s\n", hash);
485 /* either way we're done with this now */
487 if (rc != SQLITE_ROW) {
488 SQLERROR(sqlite3_errmsg(db));
489 sqlite3_finalize(ifile);
494 type = sqlite3_column_type(ifile, 0);
495 if (type == SQLITE_NULL) {
496 fprintf(stderr, "no file size\n");
497 sqlite3_finalize(ifile);
501 type = sqlite3_column_type(ifile, 1);
502 if (type == SQLITE_NULL) {
503 fprintf(stderr, "no file data\n");
504 sqlite3_finalize(ifile);
508 //size = sqlite3_column_int64(ifile, 0);
509 xzdata = (void *)sqlite3_column_blob(ifile, 1);
510 blobsize = sqlite3_column_bytes(ifile, 1);
512 if (strcmp(path, "-")) {
514 tmpfile = malloc(len+8+1);
516 fprintf(stderr, "malloc error\n");
519 sprintf(tmpfile, "%sXXXXXX", path);
521 out = open(tmpfile, O_CREAT|O_WRONLY|O_TRUNC, 0600);
523 fprintf(stderr, "can't open output file %s: %s\n",
524 tmpfile, strerror(errno));
525 sqlite3_finalize(ifile);
534 fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
536 uncompresslzma(xzdata, blobsize, out);
538 sqlite3_finalize(ifile);
542 if (chmod(tmpfile, mode) == -1) {
543 fprintf(stderr, "can't chmod %s: %s\n", tmpfile,
546 } else if (rename(tmpfile, path) == -1) {
547 fprintf(stderr, "extract rename failed: %s\n",
553 if (rc == 0 && tmpfile) {
554 if (unlink(tmpfile) == -1) {
555 fprintf(stderr, "unlink tmpfile %s fail: %s\n",
564 static int run_for_hash(sqlite3 *db, char *sql, char *hash) {
568 rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
569 if (rc != SQLITE_OK) {
570 SQLERROR(sqlite3_errmsg(db));
576 sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
578 rc = sqlite3_step(ifile);
579 } while (rc == SQLITE_ROW);
581 sqlite3_finalize(ifile);
583 return rc == SQLITE_DONE;
586 #define SQLERP(db, msg) fprintf(stderr, "%s: %s\n", msg, sqlite3_errmsg(db))
588 static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) {
589 if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) {
598 /* clear existing for this hash */
600 if (!run_for_hash(db, "delete from elflibraries where file = ?", hash)) {
601 SQLERP(db, "error clearing elf library");
605 if (!run_for_hash(db, "delete from elfneeded where file = ?", hash)) {
606 SQLERP(db, "error clearing elf needed");
610 hdr = libelf_header(content);
611 /* if lib, set soname */
612 if (libelf_type(content) == ET_DYN) {
613 char *soname = libelf_soname(content);
616 sqlite3_prepare_v2(db, "insert into elflibraries (file,soname) values (?,?)",-1, &ifile, 0);
617 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
618 sqlite3_bind_text(ifile,2,soname,-1,SQLITE_STATIC);
619 rc = sqlite3_step(ifile);
620 if (rc != SQLITE_DONE) {
621 SQLERROR(sqlite3_errmsg(db));
622 sqlite3_finalize(ifile);
623 fprintf(stderr, "error setting library soname\n");
626 sqlite3_finalize(ifile);
628 fprintf(stderr, "can't find soname\n");
632 /* if exe, set neededs */
633 if (libelf_type(content) == ET_EXEC) {
634 Elf64_Shdr *dsect = 0;
637 elf = (char *)content;
638 /* find program header table */
639 for (i = 0; i < hdr->e_phnum; i++) {
640 phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
641 if (phdr->p_type == PT_DYNAMIC) {
642 dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
646 /* no dynamic section found */
651 dyn = (Elf64_Dyn *)(elf + dsect->sh_offset);
656 dyn = (Elf64_Dyn *)dsect;
658 dsect = libelf_section(elf, SHT_DYNAMIC);
661 strsect = libelf_section_n(elf, dsect->sh_link);
662 strtab = elf + strsect->sh_offset;
664 sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
665 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
666 while (dyn->d_tag != DT_NULL) {
667 if (dyn->d_tag == DT_NEEDED) {
671 need = strtab + dyn->d_un.d_val;
672 if (strlen(need) == 0) continue;
673 sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
675 fprintf(stderr, "%s needs %s\n", hash, need);
677 rc = sqlite3_step(ifile);
678 if (rc != SQLITE_DONE) {
679 SQLERP(db, "error setting needed library");
680 sqlite3_finalize(ifile);
683 sqlite3_reset(ifile);
687 sqlite3_finalize(ifile);
693 int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
697 unsigned char tmp[32];
698 struct sha256_state md;
699 sqlite3_stmt *ifile = 0;
700 int haverow = 0,havedata = 0;
708 if (!zpm || !zpm->db || !path) {
712 /* use local if caller didn't pass in room */
718 fprintf(stderr, "zpm_import unused flags = %d\n", flags);
721 fd = open(path, O_RDONLY);
724 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
727 if (fstat(fd, &sbuf) == -1) {
729 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
732 /* not a regular file? */
733 if (!S_ISREG(sbuf.st_mode)) {
735 switch (sbuf.st_mode & S_IFMT) {
736 case S_IFSOCK: ftype = "socket"; break;
737 case S_IFLNK : ftype = "symlink"; break;
738 case S_IFBLK : ftype = "block device"; break;
739 case S_IFDIR : ftype = "directory"; break;
740 case S_IFCHR : ftype = "character device"; break;
741 case S_IFIFO : ftype = "fifo"; break;
742 default: ftype = "unknown file type"; break;
744 /* TODO this is ok, just stored differently */
745 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
750 content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
754 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
760 sha256_process(&md, content, sbuf.st_size);
761 sha256_done(&md, tmp);
763 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
767 /* TODO check null */
768 sqlite3 *db = zpm->db;
770 /* prepare and bind */
772 rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
773 if (rc != SQLITE_OK) {
774 SQLERROR(sqlite3_errmsg(db));
775 munmap(content, sbuf.st_size);
781 sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
783 rc = sqlite3_step(ifile);
785 if (rc != SQLITE_DONE) {
786 if (rc != SQLITE_ROW) {
787 /* didn't find a row */
788 SQLERROR(sqlite3_errmsg(db));
789 munmap(content, sbuf.st_size);
793 type = sqlite3_column_type(ifile, 0);
794 if (type == SQLITE_NULL) {
795 /* TODO assert, this shouldn't be possible? */
796 fprintf(stderr, "no file size\n");
797 sqlite3_finalize(ifile);
798 munmap(content, sbuf.st_size);
801 type = sqlite3_column_type(ifile, 1);
802 if (type == SQLITE_NULL) {
803 /* TODO assert, this shouldn't be possible? */
804 fprintf(stderr, "no file data\n");
805 sqlite3_finalize(ifile);
806 munmap(content, sbuf.st_size);
808 /* which is fine, just need to update the row then */
810 havedata = sqlite3_column_int(ifile, 1);
813 sqlite3_finalize(ifile);
817 outbuf = compresslzma(content, sbuf.st_size, &outlen);
819 fprintf(stderr, "compresslzma failed\n");
820 munmap(content, sbuf.st_size);
826 rc = sqlite3_prepare_v2(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
828 rc = sqlite3_prepare_v2(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
831 if (rc != SQLITE_OK) {
832 SQLERROR(sqlite3_errmsg(db));
833 fprintf(stderr, "cant prepare data\n");
834 munmap(content, sbuf.st_size);
838 rc = sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
839 if (rc != SQLITE_OK) {
840 SQLERROR(sqlite3_errmsg(db));
841 sqlite3_finalize(ifile);
842 fprintf(stderr, "cant bind size\n");
843 munmap(content, sbuf.st_size);
847 rc = sqlite3_bind_blob64(ifile, 2, outbuf,
848 (sqlite3_int64)outlen, SQLITE_STATIC);
849 if (rc != SQLITE_OK) {
850 SQLERROR(sqlite3_errmsg(db));
851 sqlite3_finalize(ifile);
852 fprintf(stderr, "cant bind content\n");
853 munmap(content, sbuf.st_size);
857 rc = sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
858 if (rc != SQLITE_OK) {
859 SQLERROR(sqlite3_errmsg(db));
860 fprintf(stderr, "cant bind hash\n");
861 sqlite3_finalize(ifile);
862 munmap(content, sbuf.st_size);
866 rc = sqlite3_step(ifile);
867 if (rc != SQLITE_DONE) {
868 SQLERROR(sqlite3_errmsg(db));
869 sqlite3_finalize(ifile);
870 munmap(content, sbuf.st_size);
873 sqlite3_finalize(ifile);
875 /* don't need the original file now */
878 if (!set_elf_info(zpm->db, hash, content, sbuf.st_size)) {
879 fprintf(stderr, "setting elf info failed\n");
880 munmap(content, sbuf.st_size);
884 munmap(content, sbuf.st_size);