Home | History | Annotate | Line # | Download | only in lib 
      1 /*
      2  * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
      3  *
      4  * Licensed under the Apache License 2.0 (the "License").  You may not use
      5  * this file except in compliance with the License.  You can obtain a copy
      6  * in the file LICENSE in the source distribution or at
      7  * https://www.openssl.org/source/license.html
      8  */
      9 
     10 #include "apps.h"
     11 #include "app_params.h"
     12 
     13 static int describe_param_type(char *buf, size_t bufsz, const OSSL_PARAM *param)
     14 {
     15     const char *type_mod = "";
     16     const char *type = NULL;
     17     int show_type_number = 0;
     18     int printed_len;
     19 
     20     switch (param->data_type) {
     21     case OSSL_PARAM_UNSIGNED_INTEGER:
     22         type_mod = "unsigned ";
     23         /* FALLTHRU */
     24     case OSSL_PARAM_INTEGER:
     25         type = "integer";
     26         break;
     27     case OSSL_PARAM_UTF8_PTR:
     28         type_mod = "pointer to a ";
     29         /* FALLTHRU */
     30     case OSSL_PARAM_UTF8_STRING:
     31         type = "UTF8 encoded string";
     32         break;
     33     case OSSL_PARAM_OCTET_PTR:
     34         type_mod = "pointer to an ";
     35         /* FALLTHRU */
     36     case OSSL_PARAM_OCTET_STRING:
     37         type = "octet string";
     38         break;
     39     default:
     40         type = "unknown type";
     41         show_type_number = 1;
     42         break;
     43     }
     44 
     45     printed_len = BIO_snprintf(buf, bufsz, "%s: ", param->key);
     46     if (printed_len > 0) {
     47         buf += printed_len;
     48         bufsz -= printed_len;
     49     }
     50     printed_len = BIO_snprintf(buf, bufsz, "%s%s", type_mod, type);
     51     if (printed_len > 0) {
     52         buf += printed_len;
     53         bufsz -= printed_len;
     54     }
     55     if (show_type_number) {
     56         printed_len = BIO_snprintf(buf, bufsz, " [%d]", param->data_type);
     57         if (printed_len > 0) {
     58             buf += printed_len;
     59             bufsz -= printed_len;
     60         }
     61     }
     62     if (param->data_size == 0)
     63         printed_len = BIO_snprintf(buf, bufsz, " (arbitrary size)");
     64     else
     65         printed_len = BIO_snprintf(buf, bufsz, " (max %zu bytes large)",
     66                                    param->data_size);
     67     if (printed_len > 0) {
     68         buf += printed_len;
     69         bufsz -= printed_len;
     70     }
     71     *buf = '\0';
     72     return 1;
     73 }
     74 
     75 int print_param_types(const char *thing, const OSSL_PARAM *pdefs, int indent)
     76 {
     77     if (pdefs == NULL) {
     78         return 1;
     79     } else if (pdefs->key == NULL) {
     80         /*
     81          * An empty list?  This shouldn't happen, but let's just make sure to
     82          * say something if there's a badly written provider...
     83          */
     84         BIO_printf(bio_out, "%*sEmpty list of %s (!!!)\n", indent, "", thing);
     85     } else {
     86         BIO_printf(bio_out, "%*s%s:\n", indent, "", thing);
     87         for (; pdefs->key != NULL; pdefs++) {
     88             char buf[200];       /* This should be ample space */
     89 
     90             describe_param_type(buf, sizeof(buf), pdefs);
     91             BIO_printf(bio_out, "%*s  %s\n", indent, "", buf);
     92         }
     93     }
     94     return 1;
     95 }
     96 
     97 void print_param_value(const OSSL_PARAM *p, int indent)
     98 {
     99     int64_t i;
    100     uint64_t u;
    101 
    102     printf("%*s%s: ", indent, "", p->key);
    103     switch (p->data_type) {
    104     case OSSL_PARAM_UNSIGNED_INTEGER:
    105         if (OSSL_PARAM_get_uint64(p, &u))
    106             BIO_printf(bio_out, "%llu\n", (unsigned long long int)u);
    107         else
    108             BIO_printf(bio_out, "error getting value\n");
    109         break;
    110     case OSSL_PARAM_INTEGER:
    111         if (OSSL_PARAM_get_int64(p, &i))
    112             BIO_printf(bio_out, "%lld\n", (long long int)i);
    113         else
    114             BIO_printf(bio_out, "error getting value\n");
    115         break;
    116     case OSSL_PARAM_UTF8_PTR:
    117         BIO_printf(bio_out, "'%s'\n", *(char **)(p->data));
    118         break;
    119     case OSSL_PARAM_UTF8_STRING:
    120         BIO_printf(bio_out, "'%s'\n", (char *)p->data);
    121         break;
    122     case OSSL_PARAM_OCTET_PTR:
    123     case OSSL_PARAM_OCTET_STRING:
    124         BIO_printf(bio_out, "<%zu bytes>\n", p->data_size);
    125         break;
    126     default:
    127         BIO_printf(bio_out, "unknown type (%u) of %zu bytes\n",
    128                    p->data_type, p->data_size);
    129         break;
    130     }
    131 }
    132 
    133