home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / misc / src / rpm / lib / dbindex.c < prev    next >
C/C++ Source or Header  |  1997-09-17  |  3KB  |  136 lines
  1. #include "config.h"
  2. #include "miscfn.h"
  3.  
  4. #include <db.h>
  5. #include <errno.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9. #include "dbindex.h"
  10. #include "rpmlib.h"
  11.  
  12. dbiIndex * dbiOpenIndex(char * filename, int flags, int perms) {
  13.     dbiIndex * db;
  14.         
  15.     db = malloc(sizeof(*db));
  16.     db->indexname = strdup(filename);
  17.     db->db = dbopen(filename, flags, perms, DB_HASH, NULL);
  18.     if (!db->db) {
  19.     free(db->indexname);
  20.     free(db);
  21.     rpmError(RPMERR_DBOPEN, "cannot open file %s: ", filename, 
  22.                   strerror(errno));
  23.     return NULL;
  24.     }
  25.  
  26.     return db;
  27. }
  28.  
  29. void dbiCloseIndex(dbiIndex * dbi) {
  30.     dbi->db->close(dbi->db);
  31.     free(dbi->indexname);
  32.     free(dbi);
  33. }
  34.  
  35. void dbiSyncIndex(dbiIndex * dbi) {
  36.     dbi->db->sync(dbi->db, 0);
  37. }
  38.  
  39. int dbiSearchIndex(dbiIndex * dbi, char * str, dbiIndexSet * set) {
  40.     DBT key, data;
  41.     int rc;
  42.  
  43.     key.data = str;
  44.     key.size = strlen(str);
  45.  
  46.     rc = dbi->db->get(dbi->db, &key, &data, 0);
  47.     if (rc == -1) {
  48.     rpmError(RPMERR_DBGETINDEX, "error getting record %s from %s",
  49.         str, dbi->indexname);
  50.     return -1;
  51.     } else if (rc == 1) {
  52.     return 1;
  53.     } 
  54.  
  55.     set->recs = data.data;
  56.     set->recs = malloc(data.size);
  57.     memcpy(set->recs, data.data, data.size);
  58.     set->count = data.size / sizeof(dbiIndexRecord);
  59.     return 0;
  60. }
  61.  
  62. int dbiUpdateIndex(dbiIndex * dbi, char * str, dbiIndexSet * set) {
  63.    /* 0 on success */
  64.     DBT key, data;
  65.     int rc;
  66.  
  67.     key.data = str;
  68.     key.size = strlen(str);
  69.  
  70.     if (set->count) {
  71.     data.data = set->recs;
  72.     data.size = set->count * sizeof(dbiIndexRecord);
  73.  
  74.     rc = dbi->db->put(dbi->db, &key, &data, 0);
  75.     if (rc) {
  76.         rpmError(RPMERR_DBPUTINDEX, "error storing record %s into %s",
  77.             str, dbi->indexname);
  78.         return 1;
  79.     }
  80.     } else {
  81.     rc = dbi->db->del(dbi->db, &key, 0);
  82.     if (rc) {
  83.         rpmError(RPMERR_DBPUTINDEX, "error removing record %s into %s",
  84.             str, dbi->indexname);
  85.         return 1;
  86.     }
  87.     }
  88.  
  89.     return 0;
  90. }
  91.  
  92. int dbiAppendIndexRecord(dbiIndexSet * set, dbiIndexRecord rec) {
  93.     set->count++;
  94.  
  95.     if (set->count == 1) {
  96.     set->recs = malloc(set->count * sizeof(dbiIndexRecord));
  97.     } else {
  98.     set->recs = realloc(set->recs, set->count * sizeof(dbiIndexRecord));
  99.     }
  100.     set->recs[set->count - 1] = rec;
  101.  
  102.     return 0;
  103. }
  104.  
  105. dbiIndexSet dbiCreateIndexRecord(void) {
  106.     dbiIndexSet set;
  107.  
  108.     set.count = 0;
  109.     return set;
  110. }
  111.     
  112. void dbiFreeIndexRecord(dbiIndexSet set) {
  113.     free(set.recs);
  114. }
  115.  
  116. /* returns 1 on failure */
  117. int dbiRemoveIndexRecord(dbiIndexSet * set, dbiIndexRecord rec) {
  118.     int from;
  119.     int to = 0;
  120.     int num = set->count;
  121.     int numCopied = 0;
  122.   
  123.     for (from = 0; from < num; from++) {
  124.     if (rec.recOffset != set->recs[from].recOffset ||
  125.         rec.fileNumber != set->recs[from].fileNumber) {
  126.         if (from != to) set->recs[to] = set->recs[from];
  127.         to++;
  128.         numCopied++;
  129.     } else {
  130.         set->count--;
  131.     }
  132.     }
  133.  
  134.     return (numCopied == num);
  135. }
  136.