X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=lib%2Fzpm.c;h=3abbc37d5d07f87ebbe5836dcfd1c2c700d6e634;hb=ddeb616cccad9c19467be36be9415cbb82a836ce;hp=96c355415e23ccf293993fc8a7ab0a013b7ee1e7;hpb=3edf33d0d240c7a48fa9631338cac29783890ce2;p=zpackage

diff --git a/lib/zpm.c b/lib/zpm.c
index 96c3554..3abbc37 100644
--- a/lib/zpm.c
+++ b/lib/zpm.c
@@ -1,3 +1,5 @@
+#define _POSIX_C_SOURCE 200809L
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -9,8 +11,10 @@
 #include <errno.h>
 
 #include "zpm.h"
+#include "elf.h"
 
 #include "sha256.h"
+
 #if 0
 struct zpm {
 	sqlite3 *db;
@@ -179,6 +183,11 @@ int zpm_commit(struct zpm *z) {
 	return 1;
 }
 
+/* wrapper for sqlite3_exec */
+int zpm_exec(struct zpm *z, const char *sql, int(*callback)(void *, int, char **, char**), void *arg, char **errmsg) {
+	return sqlite3_exec(z->db, sql, callback, arg, errmsg);
+}
+
 int zpm_rollback(struct zpm *z) {
 	char *errstr = 0;
 	sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
@@ -262,10 +271,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;
 	}
@@ -281,12 +293,9 @@ int zpm_open(struct zpm *pkg, char *path) {
 
 	pkg->db = 0;
 	pkg->path = 0;
-	pkg->version = 0;
-	pkg->release = 0;
-	pkg->pkgname = 0;
-	pkg->installed = 0;
+	pkg->current_package = 0;
 
-	rc = sqlite3_open(path, &db);
+	rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 	if (rc) {
 		SQLERROR(sqlite3_errmsg(db));
 		sqlite3_close(db);
@@ -342,11 +351,58 @@ int zpm_close(struct zpm *pkg) {
 	return 1;
 }
 
+static int zpm_sqlite_vercmp(void *not_used, int lena, const void *a,
+		int lenb, const void *b) {
+	/* not sure what the ints are, possibly string lengths */
+	if (not_used != 0) fprintf(stderr, "sqlite vercmp not_used = %p\n",
+			not_used);
+	if (lena == 0 && lenb > 0) return 1;
+	return zpm_vercmp(a, b);
+}
+
+int zpm_addvercmp(struct zpm *pkg) {
+	return sqlite3_create_collation(
+			pkg->db, "vercmp", SQLITE_UTF8, NULL,
+			zpm_sqlite_vercmp
+			);
+}
+
+/* set package struct variables, database, environment, then command line */
+int zpm_readopts(struct zpm *zpm, int ac, char **av) {
+	char *ev;
+	struct zpm_package *pkg;
+
+	if (!zpm) {
+		return -1;
+	}
+
+       	pkg = zpm->current_package;
+
+	if (pkg) {
+		ev = getenv("ZPMPACKAGE");
+		if (ev) {
+			pkg->name = dupstr(ev);
+		}
+		ev = getenv("ZPMPKGREL");
+		if (ev) {
+			pkg->release = strtol(ev, 0, 0);
+		}
+		ev = getenv("ZPMPKGVER");
+		if (ev) {
+			pkg->version = dupstr(ev);
+		}
+	}
+
+	/* now, parse the options, return optind so the caller can adjust if needed */
+
+	return av ? ac : 1;
+}
+
 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
 	int rc;
 
 	int blobsize;
-	int64_t size;
+	//int64_t size;
 	void *xzdata;
 	int type;
 	FILE *out;
@@ -371,7 +427,7 @@ int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
 		/* didn't find a row */
 		sqlite3_finalize(ifile);
 		sqlite3_close(db);
-		fprintf(stderr, "no such hash\n");
+		fprintf(stderr, "no such hash: %s\n", hash);
 		return 0;
 	}
 	/* either way we're done with this now */
@@ -397,36 +453,193 @@ int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
 		sqlite3_close(db);
 		return 0;
 	}
-	size = sqlite3_column_int64(ifile, 0);
+	//size = sqlite3_column_int64(ifile, 0);
 	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;
+}
+
+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 *soname = libelf_soname(content);
+			if (soname) {
+
+				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);
+			} else {
+				fprintf(stderr, "can't find soname\n");
+			}
+		}
+
+		/* 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);
+#if 0
+					fprintf(stderr, "%s needs %s\n", hash, need);
+#endif
+					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;
 }
 
 #if 1
-int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
+int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
 	int fd;
 	void *content;
 	struct stat sbuf;
 	unsigned char tmp[32];
-	hash_state md;
+	struct sha256_state md;
 	sqlite3_stmt *ifile;
 	int haverow = 0,havedata = 0;
 	int j,rc,type;
@@ -436,7 +649,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 	size_t outlen = 0;
 	void *outbuf;
 
-	if (!pkg || !pkg->db || !path) {
+	if (!zpm || !zpm->db || !path) {
 		return 0;
 	}
 
@@ -445,25 +658,43 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 		hash = hashbuf;
 	}
 
+	if (flags) {
+		fprintf(stderr, "zpm_import unused flags = %d\n", flags);
+	}
 	/* mmap the file */
 	fd = open(path, O_RDONLY);
 	if (fd == -1) {
+		zpm->error = errno;
 		fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
 		return 0;
 	}
 	if (fstat(fd, &sbuf) == -1) {
+		zpm->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);
+		zpm->error = EINVAL;
 		return 0;
 	}
 
 	content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
+	close(fd);
 	if (!content) {
+		zpm->error = errno;
 		fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
 		return 0;
 	}
@@ -476,15 +707,17 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 		sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
 	}
 	hash[64] = 0;
-	fprintf(stderr, "file %s: %s\n", path, hash);
+	//fprintf(stderr, "file %s: %s\n", path, hash);
 
-	/* prepare and bind */
 	/* TODO check null */
-	sqlite3 *db = pkg->db;
+	sqlite3 *db = zpm->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;
 	}
 
@@ -498,7 +731,8 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 		if (rc != SQLITE_ROW) {
 			/* didn't find a row */
 			SQLERROR(sqlite3_errmsg(db));
-			zpm_rollback(pkg);
+			zpm_rollback(zpm);
+		munmap(content, sbuf.st_size);
 			return 0;
 		}
 		haverow = 1;
@@ -508,6 +742,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);
@@ -515,6 +750,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 */
 		}
@@ -528,29 +764,28 @@ 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);
+		//fprintf(stderr, "compressed to %zu\n", outlen);
 
 		/* start a transaction */
 		// do that outside of here 
-		//zpm_begin(pkg);
+		//zpm_begin(zpm);
 
 		/* insert */
 		if (haverow) {
-			fprintf(stderr, "adding file data\n");
+			//fprintf(stderr, "adding file data\n");
 			rc = sqlite3_prepare(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
 		} else {
-			fprintf(stderr, "creating new data row\n");
+			//fprintf(stderr, "creating new data row\n");
 			rc = sqlite3_prepare(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
 		}
 		if (rc != SQLITE_OK) {
 			SQLERROR(sqlite3_errmsg(db));
 			fprintf(stderr, "cant prepare data\n");
-			zpm_rollback(pkg);
+			zpm_rollback(zpm);
+		munmap(content, sbuf.st_size);
 			return 0;
 		}
 
@@ -558,44 +793,53 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 		if (rc != SQLITE_OK) {
 			SQLERROR(sqlite3_errmsg(db));
 			fprintf(stderr, "cant bind size\n");
-			zpm_rollback(pkg);
+			zpm_rollback(zpm);
+		munmap(content, sbuf.st_size);
 			return 0;
 		}
 		sqlite3_bind_blob64(ifile, 2, outbuf, (sqlite3_int64)outlen, SQLITE_STATIC);
 		if (rc != SQLITE_OK) {
 			SQLERROR(sqlite3_errmsg(db));
 			fprintf(stderr, "cant bind content\n");
-			zpm_rollback(pkg);
+			zpm_rollback(zpm);
+		munmap(content, sbuf.st_size);
 			return 0;
 		}
 		sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
 		if (rc != SQLITE_OK) {
 			SQLERROR(sqlite3_errmsg(db));
 			fprintf(stderr, "cant bind hash\n");
-			zpm_rollback(pkg);
+			zpm_rollback(zpm);
+		munmap(content, sbuf.st_size);
 			return 0;
 		}
 		rc = sqlite3_step(ifile);
 		if (rc != SQLITE_DONE) {
 			SQLERROR(sqlite3_errmsg(db));
 			sqlite3_finalize(ifile);
-			zpm_rollback(pkg);
+			zpm_rollback(zpm);
+		munmap(content, sbuf.st_size);
 			return 0;
 		}
 		sqlite3_finalize(ifile);
 
 		/* commit */
-		//zpm_commit(pkg);
+		//zpm_commit(zpm);
 
-	} else {
 		/* don't need the original file now */
+
+	}
+
+	if (!set_elf_info(zpm->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)) {
+	if (zpm->current_package->name && (!ZPM_NOPACKAGE)) {
 		/* TODO */
 	}