rpmio/digest.c

   1 /** \ingroup signature
   2  * \file rpmio/digest.c
   3  */
   4
   5 #include "system.h"
   6
   7 #include "rpmio/digest.h"
   8
   9 #include "debug.h"
  10
  11 #define DIGESTS_MAX 11
  12 struct rpmDigestBundle_s {
  13     int index_min;                      /*!< Smallest index of active digest */
  14     int index_max;                      /*!< Largest index of active digest */
  15     off_t nbytes;                       /*!< Length of total input data */
  16     DIGEST_CTX digests[DIGESTS_MAX];    /*!< Digest contexts indexed by algo */
  17 };
  18
  19 rpmDigestBundle rpmDigestBundleNew(void)
  20 {
  21     rpmDigestBundle bundle = xcalloc(1, sizeof(*bundle));
  22     return bundle;
  23 }
  24
  25 rpmDigestBundle rpmDigestBundleFree(rpmDigestBundle bundle)
  26 {
  27     if (bundle) {
  28         for (int i = bundle->index_min; i <= bundle->index_max ; i++) {
  29             if (bundle->digests[i] == NULL)
  30                 continue;
  31             rpmDigestFinal(bundle->digests[i], NULL, NULL, 0);
  32             bundle->digests[i] = NULL;
  33         }
  34         memset(bundle, 0, sizeof(*bundle));
  35         free(bundle);
  36     }
  37     return NULL;
  38 }
  39
  40 int rpmDigestBundleAdd(rpmDigestBundle bundle, int algo,
  41                         rpmDigestFlags flags)
  42 {
  43     DIGEST_CTX ctx = NULL;
  44     if (bundle && algo > 0 && algo < DIGESTS_MAX) {
  45         if (bundle->digests[algo] == NULL) {
  46             ctx = rpmDigestInit(algo, flags);
  47             if (ctx) {
  48                 bundle->digests[algo] = ctx;
  49                 if (algo < bundle->index_min) {
  50                     bundle->index_min = algo;
  51                 }
  52                 if (algo > bundle->index_max) {
  53                     bundle->index_max = algo;
  54                 }
  55             }
  56         }
  57     }
  58     return (ctx != NULL);
  59 }
  60
  61 int rpmDigestBundleUpdate(rpmDigestBundle bundle, const void *data, size_t len)
  62 {
  63     int rc = 0;
  64     if (bundle && data && len > 0) {
  65         for (int i = bundle->index_min; i <= bundle->index_max; i++) {
  66             DIGEST_CTX ctx = bundle->digests[i];
  67             if (ctx == NULL)
  68                 continue;
  69             rc += rpmDigestUpdate(ctx, data, len);
  70         }
  71         bundle->nbytes += len;
  72     }
  73     return rc;
  74 }
  75
  76 int rpmDigestBundleFinal(rpmDigestBundle bundle,
  77                 int algo, void ** datap, size_t * lenp, int asAscii)
  78 {
  79     int rc = 0;
  80     if (bundle && algo >= bundle->index_min && algo <= bundle->index_max) {
  81         rc = rpmDigestFinal(bundle->digests[algo], datap, lenp, asAscii);
  82         bundle->digests[algo] = NULL;
  83     }
  84     return rc;
  85 }
  86
  87 DIGEST_CTX rpmDigestBundleDupCtx(rpmDigestBundle bundle, int algo)
  88 {
  89     DIGEST_CTX dup = NULL;
  90     if (bundle && algo >= bundle->index_min && algo <= bundle->index_max) {
  91         dup = rpmDigestDup(bundle->digests[algo]);
  92     }
  93     return dup;
  94 }
  95