Move print_param_types() to libapps, and give it indent argument
authorRichard Levitte <levitte@openssl.org>
Mon, 26 Aug 2019 20:08:04 +0000 (22:08 +0200)
committerRichard Levitte <levitte@openssl.org>
Wed, 28 Aug 2019 08:33:45 +0000 (10:33 +0200)
Reviewed-by: Shane Lontis <shane.lontis@oracle.com>
(Merged from https://github.com/openssl/openssl/pull/9697)

apps/build.info
apps/include/app_params.h [new file with mode: 0644]
apps/lib/app_params.c [new file with mode: 0644]
apps/list.c

index ef6fa22..9732dfb 100644 (file)
@@ -31,7 +31,7 @@ $OPENSSLSRC={-
    join(' ', @opensslsrc); -}
 # Source for libapps
 $LIBAPPSSRC=apps.c apps_ui.c opt.c fmt.c s_cb.c s_socket.c app_rand.c \
-        bf_prefix.c columns.c
+        bf_prefix.c columns.c lib/app_params.c
 
 IF[{- !$disabled{apps} -}]
   LIBS{noinst}=libapps.a
diff --git a/apps/include/app_params.h b/apps/include/app_params.h
new file mode 100644 (file)
index 0000000..2060b52
--- /dev/null
@@ -0,0 +1,13 @@
+/*
+ * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <openssl/core.h>
+
+int print_param_types(const char *thing, const OSSL_PARAM *pdefs, int indent);
+
diff --git a/apps/lib/app_params.c b/apps/lib/app_params.c
new file mode 100644 (file)
index 0000000..6419f47
--- /dev/null
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include "apps.h"
+#include "app_params.h"
+
+static int describe_param_type(char *buf, size_t bufsz, const OSSL_PARAM *param)
+{
+    const char *type_mod = "";
+    const char *type = NULL;
+    int show_type_number = 0;
+    int printed_len;
+
+    switch (param->data_type) {
+    case OSSL_PARAM_UNSIGNED_INTEGER:
+        type_mod = "unsigned ";
+        /* FALLTHRU */
+    case OSSL_PARAM_INTEGER:
+        type = "integer";
+        break;
+    case OSSL_PARAM_UTF8_PTR:
+        type_mod = "pointer to a ";
+        /* FALLTHRU */
+    case OSSL_PARAM_UTF8_STRING:
+        type = "UTF8 encoded string";
+        break;
+    case OSSL_PARAM_OCTET_PTR:
+        type_mod = "pointer to an ";
+        /* FALLTHRU */
+    case OSSL_PARAM_OCTET_STRING:
+        type = "octet string";
+        break;
+    default:
+        type = "unknown type";
+        show_type_number = 1;
+        break;
+    }
+
+    printed_len = BIO_snprintf(buf, bufsz, "%s: ", param->key);
+    if (printed_len > 0) {
+        buf += printed_len;
+        bufsz -= printed_len;
+    }
+    printed_len = BIO_snprintf(buf, bufsz, "%s%s", type_mod, type);
+    if (printed_len > 0) {
+        buf += printed_len;
+        bufsz -= printed_len;
+    }
+    if (show_type_number) {
+        printed_len = BIO_snprintf(buf, bufsz, " [%d]", param->data_type);
+        if (printed_len > 0) {
+            buf += printed_len;
+            bufsz -= printed_len;
+        }
+    }
+    if (param->data_size == 0)
+        printed_len = BIO_snprintf(buf, bufsz, " (arbitrary size)");
+    else
+        printed_len = BIO_snprintf(buf, bufsz, " (max %zu bytes large)",
+                                   param->data_size);
+    if (printed_len > 0) {
+        buf += printed_len;
+        bufsz -= printed_len;
+    }
+    *buf = '\0';
+    return 1;
+}
+
+int print_param_types(const char *thing, const OSSL_PARAM *pdefs, int indent)
+{
+    if (pdefs == NULL) {
+        BIO_printf(bio_out, "%*sNo declared %s\n", indent, " ", thing);
+    } else if (pdefs->key == NULL) {
+        /*
+         * An empty list?  This shouldn't happen, but let's just make sure to
+         * say something if there's a badly written provider...
+         */
+        BIO_printf(bio_out, "%*sEmpty list of %s (!!!)\n", indent, " ", thing);
+    } else {
+        BIO_printf(bio_out, "%*s%s:\n", indent, " ", thing);
+        for (; pdefs->key != NULL; pdefs++) {
+            char buf[200];       /* This should be ample space */
+
+            describe_param_type(buf, sizeof(buf), pdefs);
+            BIO_printf(bio_out, "%*s  %s\n", indent, " ", buf);
+        }
+    }
+    return 1;
+}
+
index 46a3c29..446a6e1 100644 (file)
 #include <openssl/provider.h>
 #include <openssl/safestack.h>
 #include "apps.h"
+#include "app_params.h"
 #include "progs.h"
 #include "opt.h"
 
 static int verbose = 0;
 
-static int describe_param_type(char *buf, size_t bufsz, const OSSL_PARAM *param)
-{
-    const char *type_mod = "";
-    const char *type = NULL;
-    int show_type_number = 0;
-    int printed_len;
-
-    switch (param->data_type) {
-    case OSSL_PARAM_UNSIGNED_INTEGER:
-        type_mod = "unsigned ";
-        /* FALLTHRU */
-    case OSSL_PARAM_INTEGER:
-        type = "integer";
-        break;
-    case OSSL_PARAM_UTF8_PTR:
-        type_mod = "pointer to a ";
-        /* FALLTHRU */
-    case OSSL_PARAM_UTF8_STRING:
-        type = "UTF8 encoded string";
-        break;
-    case OSSL_PARAM_OCTET_PTR:
-        type_mod = "pointer to an ";
-        /* FALLTHRU */
-    case OSSL_PARAM_OCTET_STRING:
-        type = "octet string";
-        break;
-    default:
-        type = "unknown type";
-        show_type_number = 1;
-        break;
-    }
-
-    printed_len = BIO_snprintf(buf, bufsz, "%s: ", param->key);
-    if (printed_len > 0) {
-        buf += printed_len;
-        bufsz -= printed_len;
-    }
-    printed_len = BIO_snprintf(buf, bufsz, "%s%s", type_mod, type);
-    if (printed_len > 0) {
-        buf += printed_len;
-        bufsz -= printed_len;
-    }
-    if (show_type_number) {
-        printed_len = BIO_snprintf(buf, bufsz, " [%d]", param->data_type);
-        if (printed_len > 0) {
-            buf += printed_len;
-            bufsz -= printed_len;
-        }
-    }
-    if (param->data_size == 0)
-        printed_len = BIO_snprintf(buf, bufsz, " (arbitrary size)");
-    else
-        printed_len = BIO_snprintf(buf, bufsz, " (max %zu bytes large)",
-                                   param->data_size);
-    if (printed_len > 0) {
-        buf += printed_len;
-        bufsz -= printed_len;
-    }
-    *buf = '\0';
-    return 1;
-}
-
-static int print_param_types(const char *thing, const OSSL_PARAM *pdefs)
-{
-    if (pdefs == NULL) {
-        BIO_printf(bio_out, "    No declared %s\n", thing);
-    } else if (pdefs->key == NULL) {
-        /*
-         * An empty list?  This shouldn't happen, but let's just make sure to
-         * say something if there's a badly written provider...
-         */
-        BIO_printf(bio_out, "    Empty list of %s (!!!)\n", thing);
-    } else {
-        BIO_printf(bio_out, "    %s:\n", thing);
-        for (; pdefs->key != NULL; pdefs++) {
-            char buf[200];       /* This should be ample space */
-
-            describe_param_type(buf, sizeof(buf), pdefs);
-            BIO_printf(bio_out, "      %s\n", buf);
-        }
-    }
-    return 1;
-}
-
 static void legacy_cipher_fn(const EVP_CIPHER *c,
                              const char *from, const char *to, void *arg)
 {
@@ -156,11 +73,11 @@ static void list_ciphers(void)
                    OSSL_PROVIDER_name(EVP_CIPHER_provider(c)));
         if (verbose) {
             print_param_types("retrievable algorithm parameters",
-                              EVP_CIPHER_gettable_params(c));
+                              EVP_CIPHER_gettable_params(c), 4);
             print_param_types("retrievable operation parameters",
-                              EVP_CIPHER_CTX_gettable_params(c));
+                              EVP_CIPHER_CTX_gettable_params(c), 4);
             print_param_types("settable operation parameters",
-                              EVP_CIPHER_CTX_settable_params(c));
+                              EVP_CIPHER_CTX_settable_params(c), 4);
         }
     }
     sk_EVP_CIPHER_pop_free(ciphers, EVP_CIPHER_meth_free);
@@ -219,11 +136,11 @@ static void list_digests(void)
                    OSSL_PROVIDER_name(EVP_MD_provider(m)));
         if (verbose) {
             print_param_types("retrievable algorithm parameters",
-                              EVP_MD_gettable_params(m));
+                              EVP_MD_gettable_params(m), 4);
             print_param_types("retrievable operation parameters",
-                              EVP_MD_CTX_gettable_params(m));
+                              EVP_MD_CTX_gettable_params(m), 4);
             print_param_types("settable operation parameters",
-                              EVP_MD_CTX_settable_params(m));
+                              EVP_MD_CTX_settable_params(m), 4);
         }
     }
     sk_EVP_MD_pop_free(digests, EVP_MD_meth_free);
@@ -266,11 +183,11 @@ static void list_macs(void)
 
         if (verbose) {
             print_param_types("retrievable algorithm parameters",
-                              EVP_MAC_gettable_params(m));
+                              EVP_MAC_gettable_params(m), 4);
             print_param_types("retrievable operation parameters",
-                              EVP_MAC_CTX_gettable_params(m));
+                              EVP_MAC_CTX_gettable_params(m), 4);
             print_param_types("settable operation parameters",
-                              EVP_MAC_CTX_settable_params(m));
+                              EVP_MAC_CTX_settable_params(m), 4);
         }
     }
     sk_EVP_MAC_pop_free(macs, EVP_MAC_free);