add zpm-hash program

[zpackage] / lib / zpm.c

diff --git a/lib/zpm.c b/lib/zpm.c
index 7be8c1e2914da7b9b8a9a905e5d05a8ff3f23314..1cbf44e6d1a9840f75f32464dc935d6de80e11b7 100644 (file)
--- 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;
@@ -260,7 +262,7 @@ static
 #include "newdb.c"
 
 int zpm_db_initialize(struct zpm *pkg) {
-       fprintf(stderr, "initializing zpm database\n");
+       //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:
@@ -297,7 +299,7 @@ int zpm_open(struct zpm *pkg, char *path) {
        appid = zpm_db_pragma(pkg, 1);
        dbver = zpm_db_pragma(pkg, 2);
 
-       fprintf(stderr, "db appid = %x, dbver = %d\n", appid, dbver);
+       //fprintf(stderr, "db appid = %x, dbver = %d\n", appid, dbver);
        switch (appid) {
                case 0: if (!zpm_db_initialize(pkg)) {
                                sqlite3_close(db);
@@ -341,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;
@@ -396,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);
 
@@ -409,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);
 
@@ -419,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;
@@ -447,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;
        }
 
@@ -471,8 +548,7 @@ 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 */
@@ -526,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);
@@ -537,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) {