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 int zpm_begin(struct zpm *z) {
  19         char *errstr = 0;
  20         sqlite3_exec(z->db, "begin;", NULL, NULL, &errstr);
  21         if (errstr) {
  22                 fprintf(stderr, "sqlite begin error: %s\n", errstr);
  23                 sqlite3_free(errstr);
  24                 return 0;
  25         }
  26         return 1;
  27 }
  28
  29 int zpm_commit(struct zpm *z) {
  30         char *errstr = 0;
  31         sqlite3_exec(z->db, "commit;", NULL, NULL, &errstr);
  32         if (errstr) {
  33                 fprintf(stderr, "sqlite commit error: %s\n", errstr);
  34                 sqlite3_free(errstr);
  35                 return 0;
  36         }
  37         return 1;
  38 }
  39
  40 /* wrapper for sqlite3_exec */
  41 int zpm_exec(struct zpm *z, const char *sql, int(*callback)(void *, int, char **, char**), void *arg, char **errmsg) {
  42         return sqlite3_exec(z->db, sql, callback, arg, errmsg);
  43 }
  44
  45 int zpm_rollback(struct zpm *z) {
  46         char *errstr = 0;
  47         sqlite3_exec(z->db, "rollback;", NULL, NULL, &errstr);
  48         if (errstr) {
  49                 fprintf(stderr, "sqlite rollback error: %s\n", errstr);
  50                 sqlite3_free(errstr);
  51                 return 0;
  52         }
  53         return 1;
  54 }
  55
  56 int zpm_db_set_pragma(struct zpm *db, int pragma, int value) {
  57         int rc;
  58         char *sql;
  59         sqlite3_stmt *s;
  60
  61         switch (pragma) {
  62                 case 1: sql = "pragma application_id = ?;"; break;
  63                 case 2: sql = "pragma user_version = ?;"; break;
  64                 default: return -1; break;
  65         }
  66
  67         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
  68
  69         if (rc != SQLITE_OK) {
  70                 SQLERROR(sqlite3_errmsg(db->db));
  71                 return -1;
  72         }
  73
  74         sqlite3_bind_int(s, 1, value);
  75         if (rc != SQLITE_OK) {
  76                 SQLERROR(sqlite3_errmsg(db->db));
  77                 fprintf(stderr, "cant bind pragma value\n");
  78                 sqlite3_finalize(s);
  79                 return -1;
  80         }
  81         rc = sqlite3_step(s);
  82         if (rc != SQLITE_DONE) {
  83                 SQLERROR(sqlite3_errmsg(db->db));
  84                 fprintf(stderr, "cant set pragma\n");
  85                 sqlite3_finalize(s);
  86                 return -1;
  87         }
  88
  89         sqlite3_finalize(s);
  90         return value;
  91 }
  92
  93 int zpm_db_pragma(struct zpm *db, int pragma) {
  94         int rc;
  95         int value = -1;
  96         char *sql = 0;
  97         sqlite3_stmt *s;
  98
  99         switch (pragma) {
 100                 case 1: sql = "pragma application_id;"; break;
 101                 case 2: sql = "pragma user_version;"; break;
 102                 default: return -1; break;
 103         }
 104
 105         rc = sqlite3_prepare_v2(db->db, sql, -1, &s, 0);
 106
 107         if (rc != SQLITE_OK) {
 108                 SQLERROR(sqlite3_errmsg(db->db));
 109                 fprintf(stderr, "%s, errnum = %d\n", sqlite3_errmsg(db->db), rc);
 110                 /* TODO just abort? */
 111                 return -1;
 112         }
 113
 114         rc = sqlite3_step(s);
 115         if (rc == SQLITE_ROW) {
 116                 value = sqlite3_column_int(s, 0);
 117         }
 118
 119         sqlite3_finalize(s);
 120         return value;
 121 }
 122
 123 static
 124 #include "newdb.c"
 125
 126 int zpm_db_initialize(struct zpm *pkg) {
 127         char *error;
 128         switch (sqlite3_exec(pkg->db, createdb, (int (*)(void *,int,char **,char **))0, NULL, &error)) {
 129                 case SQLITE_OK: break;
 130                 default:
 131                         SQLERROR(sqlite3_errmsg(pkg->db));
 132                         fprintf(stderr, "error: %s\n", error);
 133                         sqlite3_free(error);
 134                         zpm_rollback(pkg);
 135                         return 0;
 136                         break;
 137         }
 138         return 1;
 139 }
 140
 141
 142 /* assumes pkg->db is set */
 143 static int setupdb(struct zpm *zpm) {
 144         char *errstr = 0;
 145         int appid, dbver;
 146
 147         zpm->error = 0;
 148
 149         appid = zpm_db_pragma(zpm, 1);
 150         dbver = zpm_db_pragma(zpm, 2);
 151
 152         if (appid != 0x5a504442) {
 153                 fprintf(stderr, "unknown database type\n");
 154                 zpm->error = 1;
 155                 return 0;
 156         }
 157
 158         if (dbver > 1) {
 159                 fprintf(stderr, "version %d zpm db detected, this program only works with version 1 databases\n", dbver);
 160                 zpm->error = 1;
 161                 return 0;
 162         }
 163
 164         sqlite3_exec(zpm->db, "pragma foreign_keys = ON;", NULL, NULL, &errstr);
 165
 166         if (errstr) {
 167                 free(zpm->errmsg);
 168                 zpm->errmsg = strdup(errstr);
 169                 fprintf(stderr, "sqlite foreign key error: %s\n", errstr);
 170                 sqlite3_free(errstr);
 171                 zpm->error = 1;
 172                 return 0;
 173         }
 174
 175         /* TODO add vercmp */
 176
 177         return 1;
 178 }
 179
 180 struct zpm *zpm_clearmem(struct zpm *zpm) {
 181         if (!zpm) {
 182                 zpm = malloc(sizeof *zpm);
 183         }
 184
 185         if (zpm) {
 186                 *zpm = (struct zpm){0};
 187         }
 188
 189         return zpm;
 190 }
 191
 192 static void zpm_set_db_errmsg(struct zpm *zpm, const char *msg) {
 193         if (zpm) {
 194                 if (zpm->dberrmsg) {
 195                         free(zpm->dberrmsg);
 196                 }
 197                 if (msg) {
 198                         zpm->dberrmsg = strdup(msg);
 199                         if (!zpm->dberrmsg) {
 200                                 zpm->error = 1;
 201                         }
 202                 } else {
 203                         zpm->dberrmsg = 0;
 204                 }
 205         }
 206 }
 207
 208 int zpm_init(struct zpm *pkg, char *path) {
 209         int rc;
 210         sqlite3 *db = 0;
 211         int appid;
 212
 213         if (!pkg) {
 214                 return 0;
 215         }
 216
 217         zpm_clearmem(pkg);
 218
 219         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 220         if (rc) {
 221                 pkg->error = 1;
 222                 pkg->dbresult = rc;
 223                 zpm_set_db_errmsg(pkg, sqlite3_errstr(rc));
 224                 if (db) {
 225                         sqlite3_close(db);
 226                 }
 227                 fprintf(stderr, "error (%d): %s: %s\n", rc,
 228                                 pkg->dberrmsg ? pkg->dberrmsg : "null", path);
 229
 230                 return 0;
 231         }
 232         pkg->db   = db;
 233         pkg->path = strdup(path);
 234
 235         appid = zpm_db_pragma(pkg, 1);
 236
 237         switch (appid) {
 238                 case 0: if (!zpm_db_initialize(pkg)) {
 239                                 sqlite3_close(db);
 240                                 return 1;
 241                         };
 242                         break;
 243                 case 0x5a504442:
 244                         /* already initialized */
 245                         break;
 246                 default:
 247                         fprintf(stderr, "unknown database type\n");
 248                         sqlite3_close(db);
 249                         return 0;
 250                         break;
 251         }
 252
 253         if (!setupdb(pkg)) {
 254                 sqlite3_close(db);
 255                 pkg->db = 0;
 256                 return 0;
 257         }
 258         zpm_addvercmp(pkg);
 259
 260         return 1;
 261 }
 262
 263 int zpm_open(struct zpm *zpm, char *path) {
 264         int rc;
 265         sqlite3 *db = 0;
 266
 267         zpm_clearmem(zpm);
 268
 269         if (!path) {
 270                 path = getenv("ZPMDB");
 271         }
 272
 273         if (!path) {
 274                 path = "/var/lib/zpm/local.db";
 275         }
 276
 277         rc = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL);
 278         if (rc) {
 279                 SQLERROR(sqlite3_errmsg(db));
 280                 sqlite3_close(db);
 281                 zpm->error = 1;
 282                 fprintf(stderr, "path = %s\n", path);
 283                 return 0;
 284         }
 285         zpm->db   = db;
 286         zpm->path = strdup(path);
 287
 288         if (!setupdb(zpm)) {
 289                 sqlite3_close(db);
 290                 zpm->db = 0;
 291                 zpm->error = 1;
 292                 return 0;
 293         }
 294         zpm_addvercmp(zpm);
 295
 296         return 1;
 297 }
 298
 299 int zpm_close(struct zpm *pkg) {
 300         if (pkg) {
 301                 sqlite3_close(pkg->db);
 302                 free(pkg->path);
 303         }
 304         /* TODO free any malloced names and such */
 305         return 1;
 306 }
 307
 308 static int zpm_sqlite_vercmp(void *not_used, int lena, const void *a,
 309                 int lenb, const void *b) {
 310         int rv;
 311         char *bufa, *bufb;
 312
 313         if (not_used != 0) fprintf(stderr, "sqlite vercmp not_used = %p\n",
 314                         not_used);
 315         if (lena == 0 && lenb > 0) return 1;
 316         if (lenb == 0 && lena > 0) return -1;
 317
 318         bufa = sqlite3_malloc(lena+1);
 319         bufb = sqlite3_malloc(lenb+1);
 320
 321         strncpy(bufa, a, lena);
 322         strncpy(bufb, b, lenb);
 323         bufa[lena] = 0;
 324         bufb[lenb] = 0;
 325
 326         rv = zpm_vercmp(bufa, bufb);
 327         sqlite3_free(bufa);
 328         sqlite3_free(bufb);
 329         return rv;
 330 }
 331
 332 int zpm_addvercmp(struct zpm *pkg) {
 333         return sqlite3_create_collation(
 334                         pkg->db, "vercmp", SQLITE_UTF8, NULL,
 335                         zpm_sqlite_vercmp
 336                         );
 337 }
 338
 339 int zpm_extract(struct zpm *pkg, char *hash, char *path, mode_t mode) {
 340         int rc;
 341         int blobsize;
 342         void *xzdata;
 343         int type;
 344         int out;
 345         sqlite3_stmt *ifile;
 346         size_t len;
 347         char *tmpfile = 0;
 348         sqlite3 *db;
 349
 350         if (!pkg || !pkg->db) {
 351                 return 0;
 352         }
 353         db = pkg->db;
 354
 355         if (!path) {
 356                 path = "-";
 357         }
 358
 359         rc = sqlite3_prepare(db, "select size, content from files where hash = ?", -1, &ifile,0);
 360         if (rc != SQLITE_OK) {
 361                 SQLERROR(sqlite3_errmsg(db));
 362                 return 0;
 363         }
 364
 365         /* hash, filename */
 366
 367         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
 368
 369         rc = sqlite3_step(ifile);
 370
 371         if (rc == SQLITE_DONE) {
 372                 /* didn't find a row */
 373                 sqlite3_finalize(ifile);
 374                 sqlite3_close(db);
 375                 fprintf(stderr, "no such hash: %s\n", hash);
 376                 return 0;
 377         }
 378         /* either way we're done with this now */
 379
 380         if (rc != SQLITE_ROW) {
 381                 SQLERROR(sqlite3_errmsg(db));
 382                 sqlite3_finalize(ifile);
 383                 sqlite3_close(db);
 384                 return 0;
 385         }
 386
 387         type = sqlite3_column_type(ifile, 0);
 388         if (type == SQLITE_NULL) {
 389                 fprintf(stderr, "no file size\n");
 390                 sqlite3_finalize(ifile);
 391                 sqlite3_close(db);
 392                 return 0;
 393         }
 394         type = sqlite3_column_type(ifile, 1);
 395         if (type == SQLITE_NULL) {
 396                 fprintf(stderr, "no file data\n");
 397                 sqlite3_finalize(ifile);
 398                 sqlite3_close(db);
 399                 return 0;
 400         }
 401         //size = sqlite3_column_int64(ifile, 0);
 402         xzdata = (void *)sqlite3_column_blob(ifile, 1);
 403         blobsize = sqlite3_column_bytes(ifile, 1);
 404
 405         if (strcmp(path, "-")) {
 406                 len = strlen(path);
 407                 tmpfile = malloc(len+8+1);
 408                 if (!tmpfile) {
 409                         fprintf(stderr, "malloc error\n");
 410                         return 0;
 411                 }
 412                 sprintf(tmpfile, "%sXXXXXX", path);
 413
 414                 out = open(tmpfile, O_CREAT|O_WRONLY|O_TRUNC, 0600);
 415                 if (out == -1) {
 416                         fprintf(stderr, "can't open output file %s: %s\n",
 417                                         tmpfile, strerror(errno));
 418                         sqlite3_finalize(ifile);
 419                         sqlite3_close(db);
 420                         free(tmpfile);
 421                         return 0;
 422                 }
 423         } else {
 424                 out = 1;
 425         }
 426
 427 #if 0
 428         fprintf(stderr, "uncompressing %d bytes at %p, expect %lld\n", blobsize, xzdata, (long long int)size);
 429 #endif
 430         uncompresslzma(xzdata, blobsize, out);
 431         close(out);
 432         sqlite3_finalize(ifile);
 433
 434         rc = 1;
 435         if (tmpfile) {
 436                 if (chmod(tmpfile, mode) == -1) {
 437                         fprintf(stderr, "can't chmod %s: %s\n", tmpfile,
 438                                         strerror(errno));
 439                         rc = 0;
 440                 } else if (rename(tmpfile, path) == -1) {
 441                         fprintf(stderr, "extract rename failed: %s\n",
 442                                         strerror(errno));
 443                         rc = 0;
 444                 }
 445         }
 446
 447         if (rc == 0 && tmpfile) {
 448                 if (unlink(tmpfile) == -1) {
 449                         fprintf(stderr, "unlink tmpfile %s fail: %s\n",
 450                                         tmpfile,
 451                                         strerror(errno));
 452                 }
 453         }
 454
 455         free(tmpfile);
 456         return rc;
 457 }
 458
 459 static int run_for_hash(sqlite3 *db, char *sql, char *hash) {
 460         int rc;
 461         sqlite3_stmt *ifile;
 462
 463         rc = sqlite3_prepare_v2(db, sql, -1, &ifile, 0);
 464         if (rc != SQLITE_OK) {
 465                 SQLERROR(sqlite3_errmsg(db));
 466                 return 0;
 467         }
 468
 469         /* hash, filename */
 470
 471         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
 472         do {
 473                 rc = sqlite3_step(ifile);
 474         } while (rc == SQLITE_ROW);
 475
 476         sqlite3_finalize(ifile);
 477
 478         return rc == SQLITE_DONE;
 479 }
 480
 481 #define SQLERP(db, msg) fprintf(stderr, "%s: %s\n", msg, sqlite3_errmsg(db))
 482
 483 static int set_elf_info(struct zpm *zpm, char *hash, char *content,
 484                 size_t length) {
 485
 486         char *strtab;
 487         Elf64_Dyn *dyn;
 488         int i;
 489         Elf64_Phdr *phdr;
 490         Elf64_Ehdr *hdr;
 491         sqlite3_stmt *ifile;
 492         sqlite3 *db = zpm->db;
 493
 494         if (length < sizeof (Elf64_Ehdr) || !libelf_iself(content)) {
 495                 /* not an elf file */
 496                 return 1;
 497         }
 498
 499         /* clear existing for this hash */
 500
 501         if (!run_for_hash(db, "delete from elflibraries where file = ?", hash)) {
 502                 SQLERP(db, "error clearing elf library");
 503                 return 0;
 504         }
 505
 506         if (!run_for_hash(db, "delete from elfneeded where file = ?", hash)) {
 507                 SQLERP(db, "error clearing elf needed");
 508                 return 0;
 509         }
 510
 511         hdr = libelf_header(content);
 512         /* if lib, set soname */
 513         if (libelf_type(content) == ET_DYN) {
 514                 char *soname = libelf_soname(content);
 515                 if (soname) {
 516                         zpm_db_run(zpm, "insert into elflibraries (file,soname) values (%Q,%Q);", hash, soname);
 517                         if (zpm->error) {
 518                                 return 0;
 519                         }
 520                 }
 521                 /* some dyn don't have an soname, so we don't
 522                  * need to warn */
 523         }
 524
 525         /* if exe, set neededs */
 526         /* libraries can have neededs too */
 527         if (libelf_type(content) == ET_EXEC || libelf_type(content) == ET_DYN) {
 528                 Elf64_Shdr *dsect = 0;
 529                 char *elf;
 530
 531                 elf = (char *)content;
 532                 /* find program header table */
 533                 for (i = 0; i < hdr->e_phnum; i++) {
 534                         phdr = (Elf64_Phdr *)(elf + hdr->e_phoff + i * hdr->e_phentsize);
 535                         if (phdr->p_type == PT_DYNAMIC) {
 536                                 dsect = (Elf64_Shdr *)(elf + phdr->p_offset);
 537                         }
 538                 }
 539                 if (!dsect) {
 540                         /* no dynamic section found */
 541                         return 1;
 542                 }
 543
 544                 dyn = (Elf64_Dyn *)dsect;
 545
 546                 dsect = libelf_section(elf, SHT_DYNAMIC);
 547                 Elf64_Shdr *strsect;
 548
 549                 strsect = libelf_section_n(elf, dsect->sh_link);
 550                 strtab = elf + strsect->sh_offset;
 551
 552                 sqlite3_prepare_v2(db, "insert into elfneeded (file,needed) values (?,?)",-1, &ifile, 0);
 553                 sqlite3_bind_text(ifile,1,hash,64,SQLITE_STATIC);
 554                 while (dyn->d_tag != DT_NULL) {
 555                         if (dyn->d_tag == DT_NEEDED) {
 556                                 char *need;
 557                                 int rc;
 558
 559                                 need = strtab + dyn->d_un.d_val;
 560                                 if (strlen(need) == 0) continue;
 561                                 sqlite3_bind_text(ifile,2,need,strlen(need),SQLITE_STATIC);
 562 #if 0
 563                                 fprintf(stderr, "%s needs %s\n", hash, need);
 564 #endif
 565                                 rc = sqlite3_step(ifile);
 566                                 if (rc != SQLITE_DONE) {
 567                                         SQLERP(db, "error setting needed library");
 568                                         sqlite3_finalize(ifile);
 569                                         return 0;
 570                                 }
 571                                 sqlite3_reset(ifile);
 572                         }
 573                         dyn++;
 574                 }
 575                 sqlite3_finalize(ifile);
 576         }
 577         return 1;
 578 }
 579
 580 int zpm_import(struct zpm *zpm, char *path, uint32_t flags, char *hash) {
 581         int fd;
 582         void *content = 0;
 583         struct stat sbuf;
 584         sqlite3_stmt *ifile = 0;
 585         int haverow = 0,havedata = 0;
 586         int rc,type;
 587         char hashbuf[65];
 588
 589         /* xz compress it */
 590         size_t outlen = 0;
 591         void *outbuf;
 592
 593         if (!zpm || !zpm->db || !path) {
 594                 return 0;
 595         }
 596
 597         /* use local if caller didn't pass in room */
 598         if (!hash) {
 599                 hash = hashbuf;
 600         }
 601
 602         if (flags) {
 603                 fprintf(stderr, "zpm_import unused flags = %d\n", flags);
 604         }
 605         /* mmap the file */
 606         fd = open(path, O_RDONLY);
 607         if (fd == -1) {
 608                 zpm->error = errno;
 609                 fprintf(stderr, "%s can't open %s: %s\n", __FUNCTION__, path,strerror(errno));
 610                 return 0;
 611         }
 612         if (fstat(fd, &sbuf) == -1) {
 613                 zpm->error = errno;
 614                 fprintf(stderr, "%s can't fstat %s: %s\n", __FUNCTION__, path,strerror(errno));
 615                 return 0;
 616         }
 617         /* not a regular file? */
 618         if (!S_ISREG(sbuf.st_mode)) {
 619                 char *ftype;
 620                 switch (sbuf.st_mode & S_IFMT) {
 621                         case S_IFSOCK: ftype = "socket"; break;
 622                         case S_IFLNK : ftype = "symlink"; break;
 623                         case S_IFBLK : ftype = "block device"; break;
 624                         case S_IFDIR : ftype = "directory"; break;
 625                         case S_IFCHR : ftype = "character device"; break;
 626                         case S_IFIFO : ftype = "fifo"; break;
 627                         default: ftype = "unknown file type"; break;
 628                 }
 629                 /* TODO this is ok, just stored differently */
 630                 fprintf(stderr, "%s can't import %s file: %s\n", __FUNCTION__, ftype, path);
 631                 zpm->error = EINVAL;
 632                 return 0;
 633         }
 634
 635         content = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, fd, 0);
 636         close(fd);
 637         if (!content) {
 638                 zpm->error = errno;
 639                 fprintf(stderr, "%s can't mmap %s: %s\n", __FUNCTION__, path,strerror(errno));
 640                 return 0;
 641         }
 642
 643         zpm_hash_mem(content, sbuf.st_size, hash);
 644         hash[64] = 0;
 645
 646         /* TODO check null */
 647         sqlite3 *db = zpm->db;
 648
 649         /* prepare and bind */
 650
 651         rc = sqlite3_prepare_v2(db, "select size, content is not null from files where hash = ?", -1, &ifile,0);
 652         if (rc != SQLITE_OK) {
 653                 SQLERROR(sqlite3_errmsg(db));
 654                 munmap(content, sbuf.st_size);
 655                 return 0;
 656         }
 657
 658         /* hash, filename */
 659
 660         sqlite3_bind_text(ifile, 1, hash, 64, SQLITE_STATIC);
 661
 662         rc = sqlite3_step(ifile);
 663
 664         if (rc != SQLITE_DONE) {
 665                 if (rc != SQLITE_ROW) {
 666                         /* didn't find a row */
 667                         SQLERROR(sqlite3_errmsg(db));
 668                 munmap(content, sbuf.st_size);
 669                         return 0;
 670                 }
 671                 haverow = 1;
 672                 type = sqlite3_column_type(ifile, 0);
 673                 if (type == SQLITE_NULL) {
 674                         /* TODO assert, this shouldn't be possible? */
 675                         fprintf(stderr, "no file size\n");
 676                         sqlite3_finalize(ifile);
 677                 munmap(content, sbuf.st_size);
 678                         return 0;
 679                 }
 680                 type = sqlite3_column_type(ifile, 1);
 681                 if (type == SQLITE_NULL) {
 682                         /* TODO assert, this shouldn't be possible? */
 683                         fprintf(stderr, "no file data\n");
 684                         sqlite3_finalize(ifile);
 685                 munmap(content, sbuf.st_size);
 686                         return 0;
 687                         /* which is fine, just need to update the row then */
 688                 }
 689                 havedata = sqlite3_column_int(ifile, 1);
 690         }
 691
 692         sqlite3_finalize(ifile);
 693
 694         if (!havedata) {
 695                 /* compress */
 696 //              fprintf(stderr, "compressing\n");
 697                 outbuf = compresslzma(content, sbuf.st_size, &outlen);
 698                 if (!outbuf) {
 699                         fprintf(stderr, "compresslzma failed\n");
 700                         munmap(content, sbuf.st_size);
 701                         return 0;
 702                 }
 703 ////            fprintf(stderr, "compress finished\n");
 704
 705                 /* insert */
 706                 if (haverow) {
 707                         rc = sqlite3_prepare_v2(db, "update files set size = ?, content = ? where hash = ?", -1, &ifile,0);
 708                 } else {
 709                         rc = sqlite3_prepare_v2(db, "insert into files (size, content, hash) values (?,?,?)", -1, &ifile,0);
 710                 }
 711
 712                 if (rc != SQLITE_OK) {
 713                         SQLERROR(sqlite3_errmsg(db));
 714                         fprintf(stderr, "cant prepare data\n");
 715                         munmap(content, sbuf.st_size);
 716                         return 0;
 717                 }
 718
 719                 rc = sqlite3_bind_int64(ifile, 1, (sqlite3_int64)sbuf.st_size);
 720                 if (rc != SQLITE_OK) {
 721                         SQLERROR(sqlite3_errmsg(db));
 722                         sqlite3_finalize(ifile);
 723                         fprintf(stderr, "cant bind size\n");
 724                         munmap(content, sbuf.st_size);
 725                         return 0;
 726                 }
 727
 728                 rc = sqlite3_bind_blob64(ifile, 2, outbuf,
 729                                 (sqlite3_int64)outlen, SQLITE_STATIC);
 730                 if (rc != SQLITE_OK) {
 731                         SQLERROR(sqlite3_errmsg(db));
 732                         sqlite3_finalize(ifile);
 733                         fprintf(stderr, "cant bind content\n");
 734                         munmap(content, sbuf.st_size);
 735                         return 0;
 736                 }
 737
 738                 rc = sqlite3_bind_text(ifile, 3, hash, 64, SQLITE_STATIC);
 739                 if (rc != SQLITE_OK) {
 740                         SQLERROR(sqlite3_errmsg(db));
 741                         fprintf(stderr, "cant bind hash\n");
 742                         sqlite3_finalize(ifile);
 743                         munmap(content, sbuf.st_size);
 744                         return 0;
 745                 }
 746
 747                 rc = sqlite3_step(ifile);
 748                 if (rc != SQLITE_DONE) {
 749                         SQLERROR(sqlite3_errmsg(db));
 750                         sqlite3_finalize(ifile);
 751                         munmap(content, sbuf.st_size);
 752                         return 0;
 753                 }
 754                 sqlite3_finalize(ifile);
 755
 756                 /* don't need the original file now */
 757         }
 758
 759         if (!set_elf_info(zpm, hash, content, sbuf.st_size)) {
 760                 fprintf(stderr, "setting elf info failed\n");
 761                 munmap(content, sbuf.st_size);
 762                 return 0;
 763         }
 764
 765         munmap(content, sbuf.st_size);
 766
 767         /* return */
 768         return 1;
 769 }