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