X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=lib%2Fzpm.c;h=d9041ff33c6daf3b4510022fd6e7b2387ae983d9;hb=291309674a2bd7b1612460bc167544f7afd1be7b;hp=1cbf44e6d1a9840f75f32464dc935d6de80e11b7;hpb=cfbebb05d00b06bd7ac644611d94f7f689451838;p=zpackage diff --git a/lib/zpm.c b/lib/zpm.c index 1cbf44e..d9041ff 100644 --- a/lib/zpm.c +++ b/lib/zpm.c @@ -1,3 +1,5 @@ +#define _POSIX_C_SOURCE 200809L + #include #include #include @@ -9,6 +11,7 @@ #include #include "zpm.h" +#include "elf.h" #include "sha256.h" @@ -263,10 +266,13 @@ static int zpm_db_initialize(struct zpm *pkg) { //fprintf(stderr, "initializing zpm database\n"); - switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, NULL)) { + char *error; + switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) { case SQLITE_OK: break; default: SQLERROR(sqlite3_errmsg(pkg->db)); + fprintf(stderr, "error: %s\n", error); + sqlite3_free(error); return 0; break; } @@ -366,7 +372,7 @@ int zpm_readopts(struct zpm *pkg, int ac, char **av) { /* now, parse the options, return optind so the caller can adjust if needed */ - return 1; + return av ? ac : 1; } int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) { @@ -428,23 +434,27 @@ int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) { xzdata = (void *)sqlite3_column_blob(ifile, 1); blobsize = sqlite3_column_bytes(ifile, 1); - out = fopen(path, "w"); + if (strcmp(path, "-")) { + out = fopen(path, "w"); + } else { + out = stdout; + } if (!out) { fprintf(stderr, "can't open output file %s\n", path); sqlite3_finalize(ifile); sqlite3_close(db); - return 5; + return 0; } //fwrite(xzdata, blobsize, 1, stdout); //fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size); uncompresslzma(xzdata, blobsize, out); fclose(out); + chmod(path, mode); sqlite3_finalize(ifile); - return 0; - + return 1; } /* flags 0, close mmap, flags 1, return mmap fd */ @@ -489,6 +499,192 @@ int zpm_hash(char *path, char *hash, uint32_t flags) { } hash[64] = 0; munmap(content, sbuf.st_size); + return flags ? fd : 1; +} + +static sqlite3_stmt *run_for_hash(sqlite3 *db, char *sql, char *hash) { + int rc; + sqlite3_stmt *ifile; + + rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0); + if (rc != SQLITE_OK) { + SQLERROR(sqlite3_errmsg(db)); + return 0; + } + + /* hash, filename */ + + sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC); + + return ifile; +} + +static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) { + if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) { + char *strtab; + Elf64_Dyn *dyn; + int i; + Elf64_Phdr *phdr; + Elf64_Ehdr *hdr; + sqlite3_stmt *ifile; + int rc; + + /* go ahead and set up elf information now */ + /* clear existing for this hash */ + ifile = run_for_hash(db, "delete from elfinfo where file = ?", hash); + do { + rc = sqlite3_step(ifile); +#if 0 + if (rc == SQLITE_ROW) { + int nc; + fprintf(stderr, "delete row has %d columns: ", sqlite3_column_count(ifile)); + nc = sqlite3_column_count(ifile); + for (i = 0; i < nc; i++) { + char *r; + r = sqlite3_column_text(ifile, i); + fprintf(stderr, ", %s", r); + } + fprintf(stderr, "\n"); + } +#endif + } while (rc == SQLITE_ROW); + if (rc != SQLITE_DONE) { + SQLERROR(sqlite3_errmsg(db)); + sqlite3_finalize(ifile); + fprintf(stderr, "error clearing elf info: %d\n", rc); + return 0; + } + sqlite3_finalize(ifile); + ifile = run_for_hash(db, "delete from elflibraries where file = ?", hash); + do { + rc = sqlite3_step(ifile); + } while (rc == SQLITE_ROW); + if (rc != SQLITE_DONE) { + SQLERROR(sqlite3_errmsg(db)); + sqlite3_finalize(ifile); + fprintf(stderr, "error clearing elf library: %d\n", rc); + return 0; + } + sqlite3_finalize(ifile); + ifile = run_for_hash(db, "delete from elfneeded where file = ?", hash); + do { + rc = sqlite3_step(ifile); + } while (rc == SQLITE_ROW); + if (rc != SQLITE_DONE) { + SQLERROR(sqlite3_errmsg(db)); + sqlite3_finalize(ifile); + fprintf(stderr, "error clearing elf needed\n"); + return 0; + } + sqlite3_finalize(ifile); + + hdr = libelf_header(content); + /* if lib, set soname */ + if (libelf_type(content) == ET_DYN) { + char *elf; + Elf64_Shdr *shdr, *dynsect, *dynstrtab = 0; + + elf = (char *)content; + for (i = 0; i < hdr->e_shnum; i++) { + shdr = (Elf64_Shdr *)(elf + hdr->e_shoff + i * hdr->e_shentsize); + if (shdr->sh_type == SHT_DYNAMIC) { + dynsect = shdr; + } else if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) { + dynstrtab = shdr; + } + } + if (!dynstrtab) { + exit(8); + } + if (!dynsect) { + exit(9); + } + + char *name; + Elf64_Shdr *dyntab; + name = elf + dynstrtab->sh_offset; + for (i = 0; i < hdr->e_shnum; i++) { + shdr = (Elf64_Shdr *)(elf + hdr->e_shoff + i * hdr->e_shentsize); + if (shdr->sh_type == SHT_STRTAB && !strcmp(".dynstr", name+shdr->sh_name)) { + dyntab = shdr; + } + } + if (!dyntab) { + exit(10); + } + + char *dynname; + Elf64_Dyn *dent; + dynname = elf + dyntab->sh_offset; + + for (dent = (Elf64_Dyn *)(elf + dynsect->sh_offset); dent->d_tag != DT_NULL; dent++) { + if (dent->d_tag == DT_SONAME) { + char *soname = dynname + dent->d_un.d_val; + sqlite3_prepare_v2(db, "insert into elflibraries (file,soname) values (?,?)",-1, &ifile, 0); + sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC); + sqlite3_bind_text(ifile,2,soname,-1,SQLITE_STATIC); + rc = sqlite3_step(ifile); + if (rc != SQLITE_DONE) { + SQLERROR(sqlite3_errmsg(db)); + sqlite3_finalize(ifile); + fprintf(stderr, "error setting library soname\n"); + return 0; + } + sqlite3_finalize(ifile); + } + } + } + + /* if exe, set neededs */ + if (libelf_type(content) == ET_EXEC) { + Elf64_Shdr *dsect; + char *elf; + + elf = (char *)content; + /* find program header table */ + for (i = 0; i < hdr->e_phnum; i++) { + phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize); + if (phdr->p_type == PT_DYNAMIC) { + dsect = (Elf64_Shdr *)(elf + phdr->p_offset); + } + } + dyn = (Elf64_Dyn *)(elf + dsect->sh_offset); + if (!dyn) { + exit(9); + } + dyn = (Elf64_Dyn *)dsect; + + dsect = libelf_section(elf, SHT_DYNAMIC); + Elf64_Shdr *strsect; + + strsect = libelf_section_n(elf, dsect->sh_link); + strtab = elf + strsect->sh_offset; + + sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0); + sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC); + while (dyn->d_tag != DT_NULL) { + if (dyn->d_tag == DT_NEEDED) { + char *need; + int rc; + + need = strtab + dyn->d_un.d_val; + if (strlen(need) == 0) continue; + sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC); + fprintf(stderr, "%s needs %s\n", hash, need); + rc = sqlite3_step(ifile); + if (rc != SQLITE_DONE) { + SQLERROR(sqlite3_errmsg(db)); + sqlite3_finalize(ifile); + fprintf(stderr, "error setting needed library\n"); + return 0; + } + sqlite3_reset(ifile); + } + dyn++; + } + sqlite3_finalize(ifile); + } + } return 1; } @@ -517,25 +713,41 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { hash = hashbuf; } + flags = 0; /* suppress warning, probably use to follow symlinks */ /* mmap the file */ fd = open(path, O_RDONLY); if (fd == -1) { + pkg->error = errno; fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno)); return 0; } if (fstat(fd, &sbuf) == -1) { + pkg->error = errno; fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno)); return 0; } /* not a regular file? */ if (!S_ISREG(sbuf.st_mode)) { + char *ftype; + switch (sbuf.st_mode & S_IFMT) { + case S_IFSOCK: ftype = "socket"; break; + case S_IFLNK : ftype = "symlink"; break; + case S_IFBLK : ftype = "block device"; break; + case S_IFDIR : ftype = "directory"; break; + case S_IFCHR : ftype = "character device"; break; + case S_IFIFO : ftype = "fifo"; break; + default: ftype = "unknown file type"; break; + } /* TODO this is ok, just stored differently */ - fprintf(stderr, "%s non-regular files unsupported %s\n", __FUNCTION__, path); + fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path); + pkg->error = EINVAL; return 0; } content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0); + close(fd); if (!content) { + pkg->error = errno; fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno)); return 0; } @@ -550,13 +762,15 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { hash[64] = 0; //fprintf(stderr, "file %s: %s\n", path, hash); - /* prepare and bind */ /* TODO check null */ sqlite3 *db = pkg->db; + /* prepare and bind */ + rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0); if (rc != SQLITE_OK) { SQLERROR(sqlite3_errmsg(db)); + munmap(content, sbuf.st_size); return 0; } @@ -571,6 +785,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { /* didn't find a row */ SQLERROR(sqlite3_errmsg(db)); zpm_rollback(pkg); + munmap(content, sbuf.st_size); return 0; } haverow = 1; @@ -580,6 +795,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { /* TODO assert, this shouldn't be possible? */ fprintf(stderr, "no file size\n"); sqlite3_finalize(ifile); + munmap(content, sbuf.st_size); return 0; } type = sqlite3_column_type(ifile, 1); @@ -587,6 +803,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { /* TODO assert, this shouldn't be possible? */ fprintf(stderr, "no file data\n"); sqlite3_finalize(ifile); + munmap(content, sbuf.st_size); return 0; /* which is fine, just need to update the row then */ } @@ -600,12 +817,10 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { outbuf = compresslzma(content, sbuf.st_size, &outlen); if (!outbuf) { fprintf(stderr, "compresslzma failed\n"); + munmap(content, sbuf.st_size); return 0; } //fprintf(stderr, "compressed to %zu\n", outlen); - /* don't need the original file now */ - munmap(content, sbuf.st_size); - close(fd); /* start a transaction */ // do that outside of here @@ -623,6 +838,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { SQLERROR(sqlite3_errmsg(db)); fprintf(stderr, "cant prepare data\n"); zpm_rollback(pkg); + munmap(content, sbuf.st_size); return 0; } @@ -631,6 +847,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { SQLERROR(sqlite3_errmsg(db)); fprintf(stderr, "cant bind size\n"); zpm_rollback(pkg); + munmap(content, sbuf.st_size); return 0; } sqlite3_bind_blob64(ifile, 2, outbuf, (sqlite3_int64)outlen, SQLITE_STATIC); @@ -638,6 +855,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { SQLERROR(sqlite3_errmsg(db)); fprintf(stderr, "cant bind content\n"); zpm_rollback(pkg); + munmap(content, sbuf.st_size); return 0; } sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC); @@ -645,6 +863,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { SQLERROR(sqlite3_errmsg(db)); fprintf(stderr, "cant bind hash\n"); zpm_rollback(pkg); + munmap(content, sbuf.st_size); return 0; } rc = sqlite3_step(ifile); @@ -652,6 +871,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { SQLERROR(sqlite3_errmsg(db)); sqlite3_finalize(ifile); zpm_rollback(pkg); + munmap(content, sbuf.st_size); return 0; } sqlite3_finalize(ifile); @@ -659,12 +879,17 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) { /* commit */ //zpm_commit(pkg); - } else { /* don't need the original file now */ + + } + + if (!set_elf_info(pkg->db, hash, content, sbuf.st_size)) { + fprintf(stderr, "setting elf info failed\n"); munmap(content, sbuf.st_size); - close(fd); + return 0; } + munmap(content, sbuf.st_size); /* if package and not nopackage flag, add to package */ if (pkg->pkgname && (!ZPM_NOPACKAGE)) {