pd.if.org Git - zpackage/blob - lib/zpm.c

   1 #define _POSIX_C_SOURCE 200809L
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <sys/mman.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11 #include <errno.h>
  12
  13 #include "zpm.h"
  14 #include "elf.h"
  15
  16 #include "sha256.h"
  17
  18 #if 0
  19 struct zpm {
  20         sqlite3 *db;
  21         char *path; /* path to package file */
  22         char *version;
  23         int release;
  24         char *pkgname;
  25         time_t installed; /* install time, 0 for not installed */
  26 };
  27
  28 struct zpm_file {
  29         char *path;
  30         int mode;
  31         uint32_t filetype;
  32         char *tags;
  33         char *owner;
  34         char *group;
  35         char *hash; /* could be fixed length */
  36         time_t mtime;
  37         struct zpm_file *next; /* so you can make a linked list */
  38 };
  39
  40 /* NULL?  Create? */
  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 */
  44
  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 */
  48 #define ZPM_MODE 0x1
  49 #define ZPM_OWNER 0x2
  50 #define ZPM_MTIME 0x4
  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
  58
  59 int zpm_import(struct zpm *zp, char *path, uint32_t flags, uint8_t *hash);
  60
  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);
  64
  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);
  69
  70 /* export hash to dest */
  71 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode);
  72
  73 /* export path to dest */
  74 int zpm_export(struct zpm *zp, char *path, uint32_t flags, char *dest);
  75
  76 int zpm_close(struct zpm *zp);
  77
  78 /* attach a signature to a package */
  79 int zpm_sign(struct zpm *z, size_t s, void *signature);
  80
  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);
  84
  85 /* get file information */
  86 int zpm_stat(struct zpm *z, struct zpm_file *f, int n);
  87
  88 /* will also set the package context to the new package */
  89 int zpm_newpkg(struct zpm *z, char *base, char *version, int release);
  90
  91 /* transactions */
  92 int zpm_begin(struct zpm *z);
  93 int zpm_commit(struct zpm *z);
  94 int zpm_rollback(struct zpm *z);
  95
  96 /* higher level operations */
  97
  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);
 103
 104 /* slurp up the actual blobs */
 105 /* what about versioning them if they change */
 106 int zpm_preserve(struct zpm *local);
 107
 108 /* check file integrity */
 109 int zpm_checkinstall(struct zpm *local);
 110
 111 int zpm_merge(struct zpm *z, struct zpm *src, uint32_t flags);
 112
 113 void uncompresslzma(void *buf, size_t bufsize, FILE *out);
 114 #define SQLERROR(x) fprintf(stderr, "%s %d: %s\n", __func__, __LINE__, (x))
 115 #endif
 116
 117 static char *dupstr(char *s) {
 118         size_t n;
 119         char *d;
 120
 121         n = strlen(s);
 122         d = malloc(n+1);
 123         if (d) {
 124                 d = strcpy(d, s);
 125         }
 126         return d;
 127 }
 128
 129 #if 0
 130 int zpm_newpkg(struct zpm *z, char *base, char *version, int release) {
 131         char *sql = "insert or ignore into packages (package,version,release) values (?,?,?)";
 132         int rc;
 133         sqlite3_stmt *ifile;
 134
 135         rc = sqlite3_prepare(db, sql, -1, &ifile,0);
 136         if (rc != SQLITE_OK) {
 137                 SQLERROR(sqlite3_errmsg(db));
 138                 return 0;
 139         }
 140         rc = sqlite3_bind_text(ifile, 1, base, strlen(base), SQLITE_STATIC);
 141         if (rc != SQLITE_OK) {
 142                 SQLERROR(sqlite3_errmsg(db));
 143                 fprintf(stderr, "cant bind package name\n");
 144                 zpm_rollback(pkg);
 145                 return 0;
 146         }
 147         sqlite3_bind_text(ifile, 2, version, strlen(version), SQLITE_STATIC);
 148         sqlite3_bind_int(ifile, 3, release)
 149
 150         rc = sqlite3_step(ifile);
 151
 152         if (rc != SQLITE_DONE) {
 153                 SQLERROR(sqlite3_errmsg(db));
 154                 sqlite3_finalize(ifile);
 155                 return 0;
 156         }
 157         sqlite3_finalize(ifile);
 158         z->pkg = dupstr(base);
 159         z->version = dupstr(version);
 160         z->release = release;
 161 }
 162 #endif
 163
 164 int zpm_begin(struct zpm *z) {
 165         char *errstr = 0;
 166         sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
 167         if (errstr) {
 168                 fprintf(stderr, "sqlite begin error: %s\n", errstr);
 169                 sqlite3_free(errstr);
 170                 return 0;
 171         }
 172         return 1;
 173 }
 174
 175 int zpm_commit(struct zpm *z) {
 176         char *errstr = 0;
 177         sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
 178         if (errstr) {
 179                 fprintf(stderr, "sqlite commit error: %s\n", errstr);
 180                 sqlite3_free(errstr);
 181                 return 0;
 182         }
 183         return 1;
 184 }
 185
 186 int zpm_rollback(struct zpm *z) {
 187         char *errstr = 0;
 188         sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
 189         if (errstr) {
 190                 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
 191                 sqlite3_free(errstr);
 192                 return 0;
 193         }
 194         return 1;
 195 }
 196
 197 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
 198         int rc;
 199         char *sql;
 200         sqlite3_stmt *s;
 201
 202         switch (pragma) {
 203                 case 1: sql = "pragma application_id = ?;"; break;
 204                 case 2: sql = "pragma user_version = ?;"; break;
 205                 default: return -1; break;
 206         }
 207
 208         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
 209
 210         if (rc != SQLITE_OK) {
 211                 SQLERROR(sqlite3_errmsg(db->db));
 212                 return -1;
 213         }
 214
 215         sqlite3_bind_int(s, 1, value);
 216         if (rc != SQLITE_OK) {
 217                 SQLERROR(sqlite3_errmsg(db->db));
 218                 fprintf(stderr, "cant bind pragma value\n");
 219                 sqlite3_finalize(s);
 220                 return -1;
 221         }
 222         rc = sqlite3_step(s);
 223         if (rc != SQLITE_DONE) {
 224                 SQLERROR(sqlite3_errmsg(db->db));
 225                 fprintf(stderr, "cant set pragma\n");
 226                 sqlite3_finalize(s);
 227                 return -1;
 228         }
 229
 230         sqlite3_finalize(s);
 231         return value;
 232 }
 233
 234 int zpm_db_pragma(struct zpm *db, int pragma) {
 235         int rc;
 236         int value = -1;
 237         char *sql = 0;
 238         sqlite3_stmt *s;
 239
 240         switch (pragma) {
 241                 case 1: sql = "pragma application_id;"; break;
 242                 case 2: sql = "pragma user_version;"; break;
 243                 default: return -1; break;
 244         }
 245
 246         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
 247
 248         if (rc != SQLITE_OK) {
 249                 SQLERROR(sqlite3_errmsg(db->db));
 250                 fprintf(stderr, "%s, errnum = %d\n", sqlite3_errmsg(db->db), rc);
 251                 /* TODO just abort? */
 252                 return -1;
 253         }
 254
 255         rc = sqlite3_step(s);
 256         if (rc == SQLITE_ROW) {
 257                 value = sqlite3_column_int(s, 0);
 258         }
 259
 260         sqlite3_finalize(s);
 261         return value;
 262 }
 263
 264 static
 265 #include "newdb.c"
 266
 267 int zpm_db_initialize(struct zpm *pkg) {
 268         //fprintf(stderr, "initializing zpm database\n");
 269         char *error;
 270         switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
 271                 case SQLITE_OK: break;
 272                 default:
 273                         SQLERROR(sqlite3_errmsg(pkg->db));
 274                         fprintf(stderr, "error: %s\n", error);
 275                         sqlite3_free(error);
 276                         return 0;
 277                         break;
 278         }
 279         return 1;
 280 }
 281
 282 /* NULL?  Create? */
 283 int zpm_open(struct zpm *pkg, char *path) {
 284         int rc;
 285         char *errstr = 0;
 286         sqlite3 *db = 0;
 287         int appid, dbver;
 288
 289         pkg->db = 0;
 290         pkg->path = 0;
 291         pkg->version = 0;
 292         pkg->release = 0;
 293         pkg->pkgname = 0;
 294         pkg->installed = 0;
 295
 296         rc = sqlite3_open(path, &db);
 297         if (rc) {
 298                 SQLERROR(sqlite3_errmsg(db));
 299                 sqlite3_close(db);
 300                 return 0;
 301         }
 302         pkg->db   = db;
 303         pkg->path = dupstr(path);
 304
 305         appid = zpm_db_pragma(pkg, 1);
 306         dbver = zpm_db_pragma(pkg, 2);
 307
 308         //fprintf(stderr, "db appid = %x, dbver = %d\n", appid, dbver);
 309         switch (appid) {
 310                 case 0: if (!zpm_db_initialize(pkg)) {
 311                                 sqlite3_close(db);
 312                                 return 1;
 313                         };
 314                         break;
 315                 case 0x5a504442: break;
 316                 default:
 317                         fprintf(stderr, "unknown database type\n");
 318                         sqlite3_close(db);
 319                         return 0;
 320                         break;
 321         }
 322         if (dbver > 1) {
 323                 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
 324                         sqlite3_close(db);
 325                         return 0;
 326         }
 327
 328         sqlite3_exec(pkg->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
 329         if (errstr) {
 330                 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
 331                 sqlite3_free(errstr);
 332                 sqlite3_close(db);
 333                 return 0;
 334         }
 335
 336
 337         /* TODO if this is a new database, create structures */
 338
 339         /* get a package. what if more than one? what if none? */
 340         return 1;
 341 }
 342
 343 int zpm_close(struct zpm *pkg) {
 344         if (pkg) {
 345                 sqlite3_close(pkg->db);
 346                 free(pkg->path);
 347         }
 348         /* TODO free any malloced names and such */
 349         return 1;
 350 }
 351
 352 /* set package struct variables, database, environment, then command line */
 353 int zpm_readopts(struct zpm *pkg, int ac, char **av) {
 354         char *ev;
 355
 356         if (!pkg) {
 357                 return -1;
 358         }
 359
 360         ev = getenv("ZPMPACKAGE");
 361         if (ev) {
 362                 pkg->pkgname = dupstr(ev);
 363         }
 364         ev = getenv("ZPMPKGREL");
 365         if (ev) {
 366                 pkg->release = strtol(ev, 0, 0);
 367         }
 368         ev = getenv("ZPMPKGVER");
 369         if (ev) {
 370                 pkg->version = dupstr(ev);
 371         }
 372
 373         /* now, parse the options, return optind so the caller can adjust if needed */
 374
 375         return av ? ac : 1;
 376 }
 377
 378 int zpm_extract(struct zpm *pkg, char *hash, char *path, int mode) {
 379         int rc;
 380
 381         int blobsize;
 382         //int64_t size;
 383         void *xzdata;
 384         int type;
 385         FILE *out;
 386         sqlite3_stmt *ifile;
 387
 388         /* TODO check null */
 389         sqlite3 *db = pkg->db;
 390
 391         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
 392         if (rc != SQLITE_OK) {
 393                 SQLERROR(sqlite3_errmsg(db));
 394                 return 0;
 395         }
 396
 397         /* hash, filename */
 398
 399         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
 400
 401         rc = sqlite3_step(ifile);
 402
 403         if (rc == SQLITE_DONE) {
 404                 /* didn't find a row */
 405                 sqlite3_finalize(ifile);
 406                 sqlite3_close(db);
 407                 fprintf(stderr, "no such hash\n");
 408                 return 0;
 409         }
 410         /* either way we're done with this now */
 411
 412         if (rc != SQLITE_ROW) {
 413                 SQLERROR(sqlite3_errmsg(db));
 414                 sqlite3_finalize(ifile);
 415                 sqlite3_close(db);
 416                 return 0;
 417         }
 418
 419         type = sqlite3_column_type(ifile, 0);
 420         if (type == SQLITE_NULL) {
 421                 fprintf(stderr, "no file size\n");
 422                 sqlite3_finalize(ifile);
 423                 sqlite3_close(db);
 424                 return 0;
 425         }
 426         type = sqlite3_column_type(ifile, 1);
 427         if (type == SQLITE_NULL) {
 428                 fprintf(stderr, "no file data\n");
 429                 sqlite3_finalize(ifile);
 430                 sqlite3_close(db);
 431                 return 0;
 432         }
 433         //size = sqlite3_column_int64(ifile, 0);
 434         xzdata = (void *)sqlite3_column_blob(ifile, 1);
 435         blobsize = sqlite3_column_bytes(ifile, 1);
 436
 437         if (strcmp(path, "-")) {
 438                 out = fopen(path, "w");
 439         } else {
 440                 out = stdout;
 441         }
 442         if (!out) {
 443                 fprintf(stderr, "can't open output file %s\n", path);
 444                 sqlite3_finalize(ifile);
 445                 sqlite3_close(db);
 446                 return 0;
 447         }
 448         //fwrite(xzdata, blobsize, 1, stdout);
 449
 450         //fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
 451         uncompresslzma(xzdata, blobsize, out);
 452         fclose(out);
 453         chmod(path, mode);
 454
 455         sqlite3_finalize(ifile);
 456
 457         return 1;
 458 }
 459
 460 /* flags 0, close mmap, flags 1, return mmap fd */
 461 int zpm_hash(char *path, char *hash, uint32_t flags) {
 462         int fd;
 463         void *content;
 464         struct stat sbuf;
 465         hash_state md;
 466         int j;
 467         unsigned char tmp[32];
 468
 469         /* mmap the file */
 470         fd = open(path, O_RDONLY);
 471         if (fd == -1) {
 472                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
 473                 return 0;
 474         }
 475         if (fstat(fd, &sbuf) == -1) {
 476                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
 477                 return 0;
 478         }
 479         /* not a regular file? */
 480         if (!S_ISREG(sbuf.st_mode)) {
 481                 /* TODO this is ok, just stored differently */
 482                 fprintf(stderr, "%s non-regular files unsupported %s\n", __FUNCTION__, path);
 483                 return 0;
 484         }
 485
 486         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
 487         close(fd);
 488         if (!content) {
 489                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
 490                 return 0;
 491         }
 492
 493         /* get hash */
 494         sha256_init(&md);
 495         sha256_process(&md, content, sbuf.st_size);
 496         sha256_done(&md, tmp);
 497         for (j=0;j<32;j++) {
 498                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
 499         }
 500         hash[64] = 0;
 501         munmap(content, sbuf.st_size);
 502         return flags ? fd : 1;
 503 }
 504
 505 static sqlite3_stmt *run_for_hash(sqlite3 *db, char *sql, char *hash) {
 506         int rc;
 507         sqlite3_stmt *ifile;
 508
 509         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
 510         if (rc != SQLITE_OK) {
 511                 SQLERROR(sqlite3_errmsg(db));
 512                 return 0;
 513         }
 514
 515         /* hash, filename */
 516
 517         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
 518
 519         return ifile;
 520 }
 521
 522 static int set_elf_info(sqlite3 *db, char *hash, char *content, size_t length) {
 523         if (length >= sizeof (Elf64_Ehdr) && libelf_iself(content)) {
 524                 char *strtab;
 525                 Elf64_Dyn *dyn;
 526                 int i;
 527                 Elf64_Phdr *phdr;
 528                 Elf64_Ehdr *hdr;
 529                 sqlite3_stmt *ifile;
 530                 int rc;
 531
 532                 /* go ahead and set up elf information now */
 533                 /* clear existing for this hash */
 534                 ifile = run_for_hash(db, "delete from elfinfo where file = ?", hash);
 535                 do {
 536                         rc = sqlite3_step(ifile);
 537 #if 0
 538                         if (rc == SQLITE_ROW) {
 539                                 int nc;
 540                                 fprintf(stderr, "delete row has %d columns: ", sqlite3_column_count(ifile));
 541                                 nc = sqlite3_column_count(ifile);
 542                                 for (i = 0; i < nc; i++) {
 543                                         char *r;
 544                                         r = sqlite3_column_text(ifile, i);
 545                                         fprintf(stderr, ", %s", r);
 546                                 }
 547                                 fprintf(stderr, "\n");
 548                         }
 549 #endif
 550                 } while (rc == SQLITE_ROW);
 551                 if (rc != SQLITE_DONE) {
 552                         SQLERROR(sqlite3_errmsg(db));
 553                         sqlite3_finalize(ifile);
 554                         fprintf(stderr, "error clearing elf info: %d\n", rc);
 555                         return 0;
 556                 }
 557                 sqlite3_finalize(ifile);
 558                 ifile = run_for_hash(db, "delete from elflibraries where file = ?", hash);
 559                 do {
 560                         rc = sqlite3_step(ifile);
 561                 } while (rc == SQLITE_ROW);
 562                 if (rc != SQLITE_DONE) {
 563                         SQLERROR(sqlite3_errmsg(db));
 564                         sqlite3_finalize(ifile);
 565                         fprintf(stderr, "error clearing elf library: %d\n", rc);
 566                         return 0;
 567                 }
 568                 sqlite3_finalize(ifile);
 569                 ifile = run_for_hash(db, "delete from elfneeded where file = ?", hash);
 570                 do {
 571                         rc = sqlite3_step(ifile);
 572                 } while (rc == SQLITE_ROW);
 573                 if (rc != SQLITE_DONE) {
 574                         SQLERROR(sqlite3_errmsg(db));
 575                         sqlite3_finalize(ifile);
 576                         fprintf(stderr, "error clearing elf needed\n");
 577                         return 0;
 578                 }
 579                 sqlite3_finalize(ifile);
 580
 581                 hdr = libelf_header(content);
 582                 /* if lib, set soname */
 583                 if (libelf_type(content) == ET_DYN) {
 584                         char *elf;
 585                         Elf64_Shdr *shdr, *dynsect, *dynstrtab = 0;
 586
 587                         elf = (char *)content;
 588                         for (i = 0; i < hdr->e_shnum; i++) {
 589                                 shdr = (Elf64_Shdr *)(elf + hdr->e_shoff + i * hdr->e_shentsize);
 590                                 if (shdr->sh_type == SHT_DYNAMIC) {
 591                                         dynsect = shdr;
 592                                 } else if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) {
 593                                         dynstrtab = shdr;
 594                                 }
 595                         }
 596                         if (!dynstrtab) {
 597                                 exit(8);
 598                         }
 599                         if (!dynsect) {
 600                                 exit(9);
 601                         }
 602
 603                         char *name;
 604                         Elf64_Shdr *dyntab;
 605                         name = elf + dynstrtab->sh_offset;
 606                         for (i = 0; i < hdr->e_shnum; i++) {
 607                                 shdr = (Elf64_Shdr *)(elf + hdr->e_shoff + i * hdr->e_shentsize);
 608                                 if (shdr->sh_type == SHT_STRTAB && !strcmp(".dynstr", name+shdr->sh_name)) {
 609                                         dyntab = shdr;
 610                                 }
 611                         }
 612                         if (!dyntab) {
 613                                 exit(10);
 614                         }
 615
 616                         char *dynname;
 617                         Elf64_Dyn *dent;
 618                         dynname = elf + dyntab->sh_offset;
 619
 620                         for (dent = (Elf64_Dyn *)(elf + dynsect->sh_offset); dent->d_tag != DT_NULL; dent++) {
 621                                 if (dent->d_tag == DT_SONAME) {
 622                                         char *soname = dynname + dent->d_un.d_val;
 623                                         sqlite3_prepare_v2(db, "insert into elflibraries (file,soname) values (?,?)",-1, &ifile, 0);
 624                                         sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
 625                                         sqlite3_bind_text(ifile,2,soname,-1,SQLITE_STATIC);
 626                                         rc = sqlite3_step(ifile);
 627                                         if (rc != SQLITE_DONE) {
 628                                                 SQLERROR(sqlite3_errmsg(db));
 629                                                 sqlite3_finalize(ifile);
 630                                                 fprintf(stderr, "error setting library soname\n");
 631                                                 return 0;
 632                                         }
 633                                         sqlite3_finalize(ifile);
 634                                 }
 635                         }
 636                 }
 637
 638                 /* if exe, set neededs */
 639                 if (libelf_type(content) == ET_EXEC) {
 640                         Elf64_Shdr *dsect;
 641                         char *elf;
 642
 643                         elf = (char *)content;
 644                         /* find program header table */
 645                         for (i = 0; i < hdr->e_phnum; i++) {
 646                                 phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
 647                                 if (phdr->p_type == PT_DYNAMIC) {
 648                                         dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
 649                                 }
 650                         }
 651                         dyn = (Elf64_Dyn *)(elf + dsect->sh_offset);
 652                         if (!dyn) {
 653                                 exit(9);
 654                         }
 655                         dyn = (Elf64_Dyn *)dsect;
 656
 657                         dsect = libelf_section(elf, SHT_DYNAMIC);
 658                         Elf64_Shdr *strsect;
 659
 660                         strsect = libelf_section_n(elf, dsect->sh_link);
 661                         strtab = elf + strsect->sh_offset;
 662
 663                         sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
 664                         sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
 665                         while (dyn->d_tag != DT_NULL) {
 666                                 if (dyn->d_tag == DT_NEEDED) {
 667                                         char *need;
 668                                         int rc;
 669
 670                                         need = strtab + dyn->d_un.d_val;
 671                                         if (strlen(need) == 0) continue;
 672                                         sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
 673                                         fprintf(stderr, "%s needs %s\n", hash, need);
 674                                         rc = sqlite3_step(ifile);
 675                                         if (rc != SQLITE_DONE) {
 676                                                 SQLERROR(sqlite3_errmsg(db));
 677                                                 sqlite3_finalize(ifile);
 678                                                 fprintf(stderr, "error setting needed library\n");
 679                                                 return 0;
 680                                         }
 681                                         sqlite3_reset(ifile);
 682                                 }
 683                                 dyn++;
 684                         }
 685                         sqlite3_finalize(ifile);
 686                 }
 687         }
 688         return 1;
 689 }
 690
 691 #if 1
 692 int zpm_import(struct zpm *pkg, char *path, uint32_t flags, char *hash) {
 693         int fd;
 694         void *content;
 695         struct stat sbuf;
 696         unsigned char tmp[32];
 697         hash_state md;
 698         sqlite3_stmt *ifile;
 699         int haverow = 0,havedata = 0;
 700         int j,rc,type;
 701         char hashbuf[65];
 702
 703         /* xz compress it */
 704         size_t outlen = 0;
 705         void *outbuf;
 706
 707         if (!pkg || !pkg->db || !path) {
 708                 return 0;
 709         }
 710
 711         /* use local if caller didn't pass in room */
 712         if (!hash) {
 713                 hash = hashbuf;
 714         }
 715
 716         flags = 0; /* suppress warning, probably use to follow symlinks */
 717         /* mmap the file */
 718         fd = open(path, O_RDONLY);
 719         if (fd == -1) {
 720                 pkg->error = errno;
 721                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
 722                 return 0;
 723         }
 724         if (fstat(fd, &sbuf) == -1) {
 725                 pkg->error = errno;
 726                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
 727                 return 0;
 728         }
 729         /* not a regular file? */
 730         if (!S_ISREG(sbuf.st_mode)) {
 731                 char *ftype;
 732                 switch (sbuf.st_mode & S_IFMT) {
 733                         case S_IFSOCK: ftype = "socket"; break;
 734                         case S_IFLNK : ftype = "symlink"; break;
 735                         case S_IFBLK : ftype = "block device"; break;
 736                         case S_IFDIR : ftype = "directory"; break;
 737                         case S_IFCHR : ftype = "character device"; break;
 738                         case S_IFIFO : ftype = "fifo"; break;
 739                         default: ftype = "unknown file type"; break;
 740                 }
 741                 /* TODO this is ok, just stored differently */
 742                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
 743                 pkg->error = EINVAL;
 744                 return 0;
 745         }
 746
 747         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
 748         close(fd);
 749         if (!content) {
 750                 pkg->error = errno;
 751                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
 752                 return 0;
 753         }
 754
 755         /* get hash */
 756         sha256_init(&md);
 757         sha256_process(&md, content, sbuf.st_size);
 758         sha256_done(&md, tmp);
 759         for (j=0;j<32;j++) {
 760                 sprintf(hash+j*2, "%02x", (unsigned)tmp[j]);
 761         }
 762         hash[64] = 0;
 763         //fprintf(stderr, "file %s: %s\n", path, hash);
 764
 765         /* TODO check null */
 766         sqlite3 *db = pkg->db;
 767
 768         /* prepare and bind */
 769
 770         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
 771         if (rc != SQLITE_OK) {
 772                 SQLERROR(sqlite3_errmsg(db));
 773                 munmap(content, sbuf.st_size);
 774                 return 0;
 775         }
 776
 777         /* hash, filename */
 778
 779         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
 780
 781         rc = sqlite3_step(ifile);
 782
 783         if (rc != SQLITE_DONE) {
 784                 if (rc != SQLITE_ROW) {
 785                         /* didn't find a row */
 786                         SQLERROR(sqlite3_errmsg(db));
 787                         zpm_rollback(pkg);
 788                 munmap(content, sbuf.st_size);
 789                         return 0;
 790                 }
 791                 haverow = 1;
 792 //              fprintf(stderr, "have row for hash\n");
 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);
 799                         return 0;
 800                 }
 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);
 807                         return 0;
 808                         /* which is fine, just need to update the row then */
 809                 }
 810                 havedata = sqlite3_column_int(ifile, 1);
 811         }
 812
 813         sqlite3_finalize(ifile);
 814
 815         if (!havedata) {
 816                 /* compress */
 817                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
 818                 if (!outbuf) {
 819                         fprintf(stderr, "compresslzma failed\n");
 820                 munmap(content, sbuf.st_size);
 821                         return 0;
 822                 }
 823                 //fprintf(stderr, "compressed to %zu\n", outlen);
 824
 825                 /* start a transaction */
 826                 // do that outside of here
 827                 //zpm_begin(pkg);
 828
 829                 /* insert */
 830                 if (haverow) {
 831                         //fprintf(stderr, "adding file data\n");
 832                         rc = sqlite3_prepare(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
 833                 } else {
 834                         //fprintf(stderr, "creating new data row\n");
 835                         rc = sqlite3_prepare(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
 836                 }
 837                 if (rc != SQLITE_OK) {
 838                         SQLERROR(sqlite3_errmsg(db));
 839                         fprintf(stderr, "cant prepare data\n");
 840                         zpm_rollback(pkg);
 841                 munmap(content, sbuf.st_size);
 842                         return 0;
 843                 }
 844
 845                 sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
 846                 if (rc != SQLITE_OK) {
 847                         SQLERROR(sqlite3_errmsg(db));
 848                         fprintf(stderr, "cant bind size\n");
 849                         zpm_rollback(pkg);
 850                 munmap(content, sbuf.st_size);
 851                         return 0;
 852                 }
 853                 sqlite3_bind_blob64(ifile, 2, outbuf, (sqlite3_int64)outlen, SQLITE_STATIC);
 854                 if (rc != SQLITE_OK) {
 855                         SQLERROR(sqlite3_errmsg(db));
 856                         fprintf(stderr, "cant bind content\n");
 857                         zpm_rollback(pkg);
 858                 munmap(content, sbuf.st_size);
 859                         return 0;
 860                 }
 861                 sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
 862                 if (rc != SQLITE_OK) {
 863                         SQLERROR(sqlite3_errmsg(db));
 864                         fprintf(stderr, "cant bind hash\n");
 865                         zpm_rollback(pkg);
 866                 munmap(content, sbuf.st_size);
 867                         return 0;
 868                 }
 869                 rc = sqlite3_step(ifile);
 870                 if (rc != SQLITE_DONE) {
 871                         SQLERROR(sqlite3_errmsg(db));
 872                         sqlite3_finalize(ifile);
 873                         zpm_rollback(pkg);
 874                 munmap(content, sbuf.st_size);
 875                         return 0;
 876                 }
 877                 sqlite3_finalize(ifile);
 878
 879                 /* commit */
 880                 //zpm_commit(pkg);
 881
 882                 /* don't need the original file now */
 883
 884         }
 885
 886         if (!set_elf_info(pkg->db, hash, content, sbuf.st_size)) {
 887                 fprintf(stderr, "setting elf info failed\n");
 888                 munmap(content, sbuf.st_size);
 889                 return 0;
 890         }
 891
 892         munmap(content, sbuf.st_size);
 893
 894         /* if package and not nopackage flag, add to package */
 895         if (pkg->pkgname && (!ZPM_NOPACKAGE)) {
 896                 /* TODO */
 897         }
 898
 899         /* return */
 900         return 1;
 901 }
 902 #endif
 903
 904 #if 0
 905 int main(int ac, char **av){
 906         sqlite3 *db = 0;
 907         int rc;
 908
 909         int blobsize;
 910         int64_t size;
 911         void *xzdata;
 912         int type;
 913         FILE *out;
 914         sqlite3_stmt *ifile;
 915
 916         char *hash;
 917         char *filename;
 918
 919         if (ac < 3) {
 920                 fprintf(stderr, "usage: db hash file\n");
 921                 return 1;
 922         }
 923
 924         rc = sqlite3_open(av[1], &db);
 925         if (rc) {
 926                 SQLERROR(sqlite3_errmsg(db));
 927                 sqlite3_close(db);
 928                 return 1;
 929         }
 930
 931 }
 932 #endif
 933
 934 #if 0
 935 Packages are sqlite databases
 936
 937 get application id and userver
 938
 939 Primitive operations:
 940
 941 add path to repo
 942 associate path with package
 943 associate blob with path?
 944 add blob to repo
 945 * extract blob to a path
 946 compare blob to filesystem path
 947 create package with info
 948
 949 Extra primitives:
 950
 951 record elf information about blob
 952 compress blob
 953 uncompress blob
 954 sign a package?  What are we verifying?
 955 #endif