crypto/property/defn_cache.c

   1 /*
   2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <string.h>
  12 #include <openssl/err.h>
  13 #include <openssl/lhash.h>
  14 #include "internal/propertyerr.h"
  15 #include "internal/property.h"
  16 #include "property_lcl.h"
  17
  18 /*
  19  * Implement a property definition cache.
  20  * These functions assume that they are called under a write lock.
  21  * No attempt is made to clean out the cache, except when it is shut down.
  22  */
  23
  24 typedef struct {
  25     const char *prop;
  26     OSSL_PROPERTY_LIST *defn;
  27     char body[1];
  28 } PROPERTY_DEFN_ELEM;
  29
  30 DEFINE_LHASH_OF(PROPERTY_DEFN_ELEM);
  31
  32 static unsigned long property_defn_hash(const PROPERTY_DEFN_ELEM *a)
  33 {
  34     return OPENSSL_LH_strhash(a->prop);
  35 }
  36
  37 static int property_defn_cmp(const PROPERTY_DEFN_ELEM *a,
  38                              const PROPERTY_DEFN_ELEM *b)
  39 {
  40     return strcmp(a->prop, b->prop);
  41 }
  42
  43 static void property_defn_free(PROPERTY_DEFN_ELEM *elem)
  44 {
  45     ossl_property_free(elem->defn);
  46     OPENSSL_free(elem);
  47 }
  48
  49 static void property_defns_free(void *vproperty_defns)
  50 {
  51     LHASH_OF(PROPERTY_DEFN_ELEM) *property_defns = vproperty_defns;
  52
  53     if (property_defns != NULL) {
  54         lh_PROPERTY_DEFN_ELEM_doall(property_defns,
  55                                     &property_defn_free);
  56         lh_PROPERTY_DEFN_ELEM_free(property_defns);
  57     }
  58 }
  59
  60 static void *property_defns_new(OPENSSL_CTX *ctx) {
  61     return lh_PROPERTY_DEFN_ELEM_new(&property_defn_hash, &property_defn_cmp);
  62 }
  63
  64 static const OPENSSL_CTX_METHOD property_defns_method = {
  65     property_defns_new,
  66     property_defns_free,
  67 };
  68
  69 OSSL_PROPERTY_LIST *ossl_prop_defn_get(OPENSSL_CTX *ctx, const char *prop)
  70 {
  71     PROPERTY_DEFN_ELEM elem, *r;
  72     LHASH_OF(PROPERTY_DEFN_ELEM) *property_defns;
  73
  74     property_defns = openssl_ctx_get_data(ctx, OPENSSL_CTX_PROPERTY_DEFN_INDEX,
  75                                           &property_defns_method);
  76     if (property_defns == NULL)
  77         return NULL;
  78
  79     elem.prop = prop;
  80     r = lh_PROPERTY_DEFN_ELEM_retrieve(property_defns, &elem);
  81     return r != NULL ? r->defn : NULL;
  82 }
  83
  84 int ossl_prop_defn_set(OPENSSL_CTX *ctx, const char *prop,
  85                        OSSL_PROPERTY_LIST *pl)
  86 {
  87     PROPERTY_DEFN_ELEM elem, *old, *p = NULL;
  88     size_t len;
  89     LHASH_OF(PROPERTY_DEFN_ELEM) *property_defns;
  90
  91     property_defns = openssl_ctx_get_data(ctx, OPENSSL_CTX_PROPERTY_DEFN_INDEX,
  92                                           &property_defns_method);
  93     if (property_defns == NULL)
  94         return 0;
  95
  96     if (prop == NULL)
  97         return 1;
  98
  99     if (pl == NULL) {
 100         elem.prop = prop;
 101         lh_PROPERTY_DEFN_ELEM_delete(property_defns, &elem);
 102         return 1;
 103     }
 104     len = strlen(prop);
 105     p = OPENSSL_malloc(sizeof(*p) + len);
 106     if (p != NULL) {
 107         p->prop = p->body;
 108         p->defn = pl;
 109         memcpy(p->body, prop, len + 1);
 110         old = lh_PROPERTY_DEFN_ELEM_insert(property_defns, p);
 111         if (old != NULL) {
 112             property_defn_free(old);
 113             return 1;
 114         }
 115         if (!lh_PROPERTY_DEFN_ELEM_error(property_defns))
 116             return 1;
 117     }
 118     OPENSSL_free(p);
 119     return 0;
 120 }