X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=lib%2Fzpm.c;h=1cbf44e6d1a9840f75f32464dc935d6de80e11b7;hb=45e6432052380587bfced3c053e9dd4969cd26d5;hp=011dba77234f2f4099709d407484a8a73e448618;hpb=3b4ac94a0a91170d19d6281119d697195cce12a3;p=zpackage

diff --git a/lib/zpm.c b/lib/zpm.c
index 011dba7..1cbf44e 100644
--- a/lib/zpm.c
+++ b/lib/zpm.c
@@ -6,10 +6,12 @@
 #include <sys/mman.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <errno.h>
 
 #include "zpm.h"
 
 #include "sha256.h"
+
 #if 0
 struct zpm {
 	sqlite3 *db;
@@ -189,11 +191,94 @@ int zpm_rollback(struct zpm *z) {
 	return 1;
 }
 
+int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
+	int rc;
+	char *sql;
+	sqlite3_stmt *s;
+
+	switch (pragma) {
+		case 1: sql = "pragma application_id = ?;"; break;
+		case 2: sql = "pragma user_version = ?;"; break;
+		default: return -1; break;
+	}
+
+	rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
+
+	if (rc != SQLITE_OK) {
+		SQLERROR(sqlite3_errmsg(db->db));
+		return -1;
+	}
+
+	sqlite3_bind_int(s, 1, value);
+	if (rc != SQLITE_OK) {
+		SQLERROR(sqlite3_errmsg(db->db));
+		fprintf(stderr, "cant bind pragma value\n");
+		sqlite3_finalize(s);
+		return -1;
+	}
+	rc = sqlite3_step(s);
+	if (rc != SQLITE_DONE) {
+		SQLERROR(sqlite3_errmsg(db->db));
+		fprintf(stderr, "cant set pragma\n");
+		sqlite3_finalize(s);
+		return -1;
+	}
+
+	sqlite3_finalize(s);
+	return value;
+}
+
+int zpm_db_pragma(struct zpm *db, int pragma) {
+	int rc;
+	int value = -1;
+	char *sql = 0;
+	sqlite3_stmt *s;
+
+	switch (pragma) {
+		case 1: sql = "pragma application_id;"; break;
+		case 2: sql = "pragma user_version;"; break;
+		default: return -1; break;
+	}
+
+	rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
+
+	if (rc != SQLITE_OK) {
+		SQLERROR(sqlite3_errmsg(db->db));
+		fprintf(stderr, "%s, errnum = %d\n", sqlite3_errmsg(db->db), rc);
+		/* TODO just abort? */
+		return -1;
+	}
+
+	rc = sqlite3_step(s);
+	if (rc == SQLITE_ROW) {
+		value = sqlite3_column_int(s, 0);
+	}
+
+	sqlite3_finalize(s);
+	return value;
+}
+
+static
+#include "newdb.c"
+
+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)) {
+		case SQLITE_OK: break;
+		default:
+			SQLERROR(sqlite3_errmsg(pkg->db));
+			return 0;
+			break;
+	}
+	return 1;
+}
+
 /* NULL?  Create? */
 int zpm_open(struct zpm *pkg, char *path) {
 	int rc;
 	char *errstr = 0;
 	sqlite3 *db = 0;
+	int appid, dbver;
 
 	pkg->db = 0;
 	pkg->path = 0;
@@ -202,14 +287,38 @@ int zpm_open(struct zpm *pkg, char *path) {
 	pkg->pkgname = 0;
 	pkg->installed = 0;
 
-	/* TODO some way to determine if the DB is newly created ? */
-	/* could check for tables, if there are any, then check version, etc */
 	rc = sqlite3_open(path, &db);
 	if (rc) {
 		SQLERROR(sqlite3_errmsg(db));
 		sqlite3_close(db);
 		return 0;
 	}
+	pkg->db   = db;
+	pkg->path = dupstr(path);
+
+	appid = zpm_db_pragma(pkg, 1);
+	dbver = zpm_db_pragma(pkg, 2);
+
+	//fprintf(stderr, "db appid = %x, dbver = %d\n", appid, dbver);
+	switch (appid) {
+		case 0: if (!zpm_db_initialize(pkg)) {
+				sqlite3_close(db);
+				return 1;
+			};
+		       	break;
+		case 0x5a504442: break;
+		default:
+			fprintf(stderr, "unknown database type\n");
+			sqlite3_close(db);
+			return 0;
+			break;
+	}
+	if (dbver > 1) {
+		fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
+			sqlite3_close(db);
+			return 0;
+	}
+
 	sqlite3_exec(pkg->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
 	if (errstr) {
 		fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
@@ -218,8 +327,6 @@ int zpm_open(struct zpm *pkg, char *path) {
 		return 0;
 	}
 
-	pkg->path = dupstr(path);
-	pkg->db   = db;
 
 	/* TODO if this is a new database, create structures */
 
@@ -236,11 +343,37 @@ int zpm_close(struct zpm *pkg) {
 	return 1;
 }
 
+/* set package struct variables, database, environment, then command line */
+int zpm_readopts(struct zpm *pkg, int ac, char **av) {
+	char *ev;
+
+	if (!pkg) {
+		return -1;
+	}
+
+	ev = getenv("ZPMPACKAGE");
+	if (ev) {
+		pkg->pkgname = 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 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;
@@ -291,7 +424,7 @@ 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);
 
@@ -304,7 +437,7 @@ int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
 	}
 	//fwrite(xzdata, blobsize, 1, stdout);
 
-	fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
+	//fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
 	uncompresslzma(xzdata, blobsize, out);
 	fclose(out);
 
@@ -314,6 +447,51 @@ int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
 	
 }
 
+/* flags 0, close mmap, flags 1, return mmap fd */
+int zpm_hash(char *path, char *hash, uint32_t flags) {
+	int fd;
+	void *content;
+	struct stat sbuf;
+	hash_state md;
+	int j;
+	unsigned char tmp[32];
+
+	/* mmap the file */
+	fd = open(path, O_RDONLY);
+	if (fd == -1) {
+		fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
+		return 0;
+	}
+	if (fstat(fd, &sbuf) == -1) {
+		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)) {
+		/* TODO this is ok, just stored differently */
+		fprintf(stderr, "%s non-regular files unsupported %s\n", __FUNCTION__, path);
+		return 0;
+	}
+
+	content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
+	close(fd);
+	if (!content) {
+		fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
+		return 0;
+	}
+
+	/* get hash */
+	sha256_init(&md);
+	sha256_process(&md, content, sbuf.st_size);
+	sha256_done(&md, tmp);
+	for (j=0;j<32;j++) {
+		sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
+	}
+	hash[64] = 0;
+	munmap(content, sbuf.st_size);
+	return 1;
+}
+
 #if 1
 int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 	int fd;
@@ -342,19 +520,23 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 	/* mmap the file */
 	fd = open(path, O_RDONLY);
 	if (fd == -1) {
+		fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
 		return 0;
 	}
 	if (fstat(fd, &sbuf) == -1) {
+		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)) {
 		/* TODO this is ok, just stored differently */
+		fprintf(stderr, "%s non-regular files unsupported %s\n", __FUNCTION__, path);
 		return 0;
 	}
 
 	content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
 	if (!content) {
+		fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
 		return 0;
 	}
 
@@ -366,14 +548,13 @@ 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;
 
-	rc = sqlite3_prepare(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
+	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));
 		return 0;
@@ -421,7 +602,7 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 			fprintf(stderr, "compresslzma failed\n");
 			return 0;
 		}
-		fprintf(stderr, "compressed to %zu\n", outlen);
+		//fprintf(stderr, "compressed to %zu\n", outlen);
 		/* don't need the original file now */
 		munmap(content, sbuf.st_size);
 		close(fd);
@@ -432,10 +613,10 @@ int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 
 		/* 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) {