Add "sections" to -help output
[openssl.git] / apps / list.c
1 /*
2  * Copyright 1995-2019 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 <string.h>
11 #include <openssl/evp.h>
12 #include <openssl/err.h>
13 #include <openssl/provider.h>
14 #include <openssl/safestack.h>
15 #include <openssl/kdf.h>
16 #include "apps.h"
17 #include "app_params.h"
18 #include "progs.h"
19 #include "opt.h"
20 #include "names.h"
21
22 static int verbose = 0;
23
24 static void legacy_cipher_fn(const EVP_CIPHER *c,
25                              const char *from, const char *to, void *arg)
26 {
27     if (c != NULL) {
28         BIO_printf(arg, "  %s\n", EVP_CIPHER_name(c));
29     } else {
30         if (from == NULL)
31             from = "<undefined>";
32         if (to == NULL)
33             to = "<undefined>";
34         BIO_printf(arg, "  %s => %s\n", from, to);
35     }
36 }
37
38 DEFINE_STACK_OF(EVP_CIPHER)
39 static int cipher_cmp(const EVP_CIPHER * const *a,
40                       const EVP_CIPHER * const *b)
41 {
42     int ret = EVP_CIPHER_number(*a) - EVP_CIPHER_number(*b);
43
44     if (ret == 0)
45         ret = strcmp(OSSL_PROVIDER_name(EVP_CIPHER_provider(*a)),
46                      OSSL_PROVIDER_name(EVP_CIPHER_provider(*b)));
47
48     return ret;
49 }
50
51 static void collect_ciphers(EVP_CIPHER *cipher, void *stack)
52 {
53     STACK_OF(EVP_CIPHER) *cipher_stack = stack;
54
55     if (sk_EVP_CIPHER_push(cipher_stack, cipher) > 0)
56         EVP_CIPHER_up_ref(cipher);
57 }
58
59 static void list_ciphers(void)
60 {
61     STACK_OF(EVP_CIPHER) *ciphers = sk_EVP_CIPHER_new(cipher_cmp);
62     int i;
63
64     BIO_printf(bio_out, "Legacy:\n");
65     EVP_CIPHER_do_all_sorted(legacy_cipher_fn, bio_out);
66
67     BIO_printf(bio_out, "Provided:\n");
68     EVP_CIPHER_do_all_provided(NULL, collect_ciphers, ciphers);
69     sk_EVP_CIPHER_sort(ciphers);
70     for (i = 0; i < sk_EVP_CIPHER_num(ciphers); i++) {
71         const EVP_CIPHER *c = sk_EVP_CIPHER_value(ciphers, i);
72         STACK_OF(OPENSSL_CSTRING) *names =
73             sk_OPENSSL_CSTRING_new(name_cmp);
74
75         EVP_CIPHER_names_do_all(c, collect_names, names);
76
77         BIO_printf(bio_out, "  ");
78         print_names(bio_out, names);
79         BIO_printf(bio_out, " @ %s\n",
80                    OSSL_PROVIDER_name(EVP_CIPHER_provider(c)));
81
82         sk_OPENSSL_CSTRING_free(names);
83
84         if (verbose) {
85             print_param_types("retrievable algorithm parameters",
86                               EVP_CIPHER_gettable_params(c), 4);
87             print_param_types("retrievable operation parameters",
88                               EVP_CIPHER_gettable_ctx_params(c), 4);
89             print_param_types("settable operation parameters",
90                               EVP_CIPHER_settable_ctx_params(c), 4);
91         }
92     }
93     sk_EVP_CIPHER_pop_free(ciphers, EVP_CIPHER_free);
94 }
95
96 static void list_md_fn(const EVP_MD *m,
97                        const char *from, const char *to, void *arg)
98 {
99     if (m != NULL) {
100         BIO_printf(arg, "  %s\n", EVP_MD_name(m));
101     } else {
102         if (from == NULL)
103             from = "<undefined>";
104         if (to == NULL)
105             to = "<undefined>";
106         BIO_printf((BIO *)arg, "  %s => %s\n", from, to);
107     }
108 }
109
110 DEFINE_STACK_OF(EVP_MD)
111 static int md_cmp(const EVP_MD * const *a, const EVP_MD * const *b)
112 {
113     int ret = EVP_MD_number(*a) - EVP_MD_number(*b);
114
115     if (ret == 0)
116         ret = strcmp(OSSL_PROVIDER_name(EVP_MD_provider(*a)),
117                      OSSL_PROVIDER_name(EVP_MD_provider(*b)));
118
119     return ret;
120 }
121
122 static void collect_digests(EVP_MD *md, void *stack)
123 {
124     STACK_OF(EVP_MD) *digest_stack = stack;
125
126     if (sk_EVP_MD_push(digest_stack, md) > 0)
127         EVP_MD_up_ref(md);
128 }
129
130 static void list_digests(void)
131 {
132     STACK_OF(EVP_MD) *digests = sk_EVP_MD_new(md_cmp);
133     int i;
134
135     BIO_printf(bio_out, "Legacy:\n");
136     EVP_MD_do_all_sorted(list_md_fn, bio_out);
137
138     BIO_printf(bio_out, "Provided:\n");
139     EVP_MD_do_all_provided(NULL, collect_digests, digests);
140     sk_EVP_MD_sort(digests);
141     for (i = 0; i < sk_EVP_MD_num(digests); i++) {
142         const EVP_MD *m = sk_EVP_MD_value(digests, i);
143         STACK_OF(OPENSSL_CSTRING) *names =
144             sk_OPENSSL_CSTRING_new(name_cmp);
145
146         EVP_MD_names_do_all(m, collect_names, names);
147
148         BIO_printf(bio_out, "  ");
149         print_names(bio_out, names);
150         BIO_printf(bio_out, " @ %s\n",
151                    OSSL_PROVIDER_name(EVP_MD_provider(m)));
152
153         sk_OPENSSL_CSTRING_free(names);
154
155         if (verbose) {
156             print_param_types("retrievable algorithm parameters",
157                               EVP_MD_gettable_params(m), 4);
158             print_param_types("retrievable operation parameters",
159                               EVP_MD_gettable_ctx_params(m), 4);
160             print_param_types("settable operation parameters",
161                               EVP_MD_settable_ctx_params(m), 4);
162         }
163     }
164     sk_EVP_MD_pop_free(digests, EVP_MD_free);
165 }
166
167 DEFINE_STACK_OF(EVP_MAC)
168 static int mac_cmp(const EVP_MAC * const *a, const EVP_MAC * const *b)
169 {
170     int ret = EVP_MAC_number(*a) - EVP_MAC_number(*b);
171
172     if (ret == 0)
173         ret = strcmp(OSSL_PROVIDER_name(EVP_MAC_provider(*a)),
174                      OSSL_PROVIDER_name(EVP_MAC_provider(*b)));
175
176     return ret;
177 }
178
179 static void collect_macs(EVP_MAC *mac, void *stack)
180 {
181     STACK_OF(EVP_MAC) *mac_stack = stack;
182
183     if (sk_EVP_MAC_push(mac_stack, mac) > 0)
184         EVP_MAC_up_ref(mac);
185 }
186
187 static void list_macs(void)
188 {
189     STACK_OF(EVP_MAC) *macs = sk_EVP_MAC_new(mac_cmp);
190     int i;
191
192     BIO_printf(bio_out, "Provided MACs:\n");
193     EVP_MAC_do_all_provided(NULL, collect_macs, macs);
194     sk_EVP_MAC_sort(macs);
195     for (i = 0; i < sk_EVP_MAC_num(macs); i++) {
196         const EVP_MAC *m = sk_EVP_MAC_value(macs, i);
197         STACK_OF(OPENSSL_CSTRING) *names =
198             sk_OPENSSL_CSTRING_new(name_cmp);
199
200         EVP_MAC_names_do_all(m, collect_names, names);
201
202         BIO_printf(bio_out, "  ");
203         print_names(bio_out, names);
204         BIO_printf(bio_out, " @ %s\n",
205                    OSSL_PROVIDER_name(EVP_MAC_provider(m)));
206
207         sk_OPENSSL_CSTRING_free(names);
208
209         if (verbose) {
210             print_param_types("retrievable algorithm parameters",
211                               EVP_MAC_gettable_params(m), 4);
212             print_param_types("retrievable operation parameters",
213                               EVP_MAC_gettable_ctx_params(m), 4);
214             print_param_types("settable operation parameters",
215                               EVP_MAC_settable_ctx_params(m), 4);
216         }
217     }
218     sk_EVP_MAC_pop_free(macs, EVP_MAC_free);
219 }
220
221 /*
222  * KDFs and PRFs
223  */
224 DEFINE_STACK_OF(EVP_KDF)
225 static int kdf_cmp(const EVP_KDF * const *a, const EVP_KDF * const *b)
226 {
227     int ret = EVP_KDF_number(*a) - EVP_KDF_number(*b);
228
229     if (ret == 0)
230         ret = strcmp(OSSL_PROVIDER_name(EVP_KDF_provider(*a)),
231                      OSSL_PROVIDER_name(EVP_KDF_provider(*b)));
232
233     return ret;
234 }
235
236 static void collect_kdfs(EVP_KDF *kdf, void *stack)
237 {
238     STACK_OF(EVP_KDF) *kdf_stack = stack;
239
240     sk_EVP_KDF_push(kdf_stack, kdf);
241     EVP_KDF_up_ref(kdf);
242 }
243
244 static void list_kdfs(void)
245 {
246     STACK_OF(EVP_KDF) *kdfs = sk_EVP_KDF_new(kdf_cmp);
247     int i;
248
249     BIO_printf(bio_out, "Provided KDFs and PDFs:\n");
250     EVP_KDF_do_all_provided(NULL, collect_kdfs, kdfs);
251     sk_EVP_KDF_sort(kdfs);
252     for (i = 0; i < sk_EVP_KDF_num(kdfs); i++) {
253         const EVP_KDF *k = sk_EVP_KDF_value(kdfs, i);
254         STACK_OF(OPENSSL_CSTRING) *names =
255             sk_OPENSSL_CSTRING_new(name_cmp);
256
257         EVP_KDF_names_do_all(k, collect_names, names);
258
259         BIO_printf(bio_out, "  ");
260         print_names(bio_out, names);
261         BIO_printf(bio_out, " @ %s\n",
262                    OSSL_PROVIDER_name(EVP_KDF_provider(k)));
263
264         sk_OPENSSL_CSTRING_free(names);
265
266         if (verbose) {
267             print_param_types("retrievable algorithm parameters",
268                               EVP_KDF_gettable_params(k), 4);
269             print_param_types("retrievable operation parameters",
270                               EVP_KDF_gettable_ctx_params(k), 4);
271             print_param_types("settable operation parameters",
272                               EVP_KDF_settable_ctx_params(k), 4);
273         }
274     }
275     sk_EVP_KDF_pop_free(kdfs, EVP_KDF_free);
276 }
277
278 static void list_missing_help(void)
279 {
280     const FUNCTION *fp;
281     const OPTIONS *o;
282
283     for (fp = functions; fp->name != NULL; fp++) {
284         if ((o = fp->help) != NULL) {
285             /* If there is help, list what flags are not documented. */
286             for ( ; o->name != NULL; o++) {
287                 if (o->helpstr == NULL)
288                     BIO_printf(bio_out, "%s %s\n", fp->name, o->name);
289             }
290         } else if (fp->func != dgst_main) {
291             /* If not aliased to the dgst command, */
292             BIO_printf(bio_out, "%s *\n", fp->name);
293         }
294     }
295 }
296
297 static void list_objects(void)
298 {
299     int max_nid = OBJ_new_nid(0);
300     int i;
301     char *oid_buf = NULL;
302     int oid_size = 0;
303
304     /* Skip 0, since that's NID_undef */
305     for (i = 1; i < max_nid; i++) {
306         const ASN1_OBJECT *obj = OBJ_nid2obj(i);
307         const char *sn = OBJ_nid2sn(i);
308         const char *ln = OBJ_nid2ln(i);
309         int n = 0;
310
311         /*
312          * If one of the retrieved objects somehow generated an error,
313          * we ignore it.  The check for NID_undef below will detect the
314          * error and simply skip to the next NID.
315          */
316         ERR_clear_error();
317
318         if (OBJ_obj2nid(obj) == NID_undef)
319             continue;
320
321         if ((n = OBJ_obj2txt(NULL, 0, obj, 1)) == 0) {
322             BIO_printf(bio_out, "# None-OID object: %s, %s\n", sn, ln);
323             continue;
324         }
325         if (n < 0)
326             break;               /* Error */
327
328         if (n > oid_size) {
329             oid_buf = OPENSSL_realloc(oid_buf, n + 1);
330             if (oid_buf == NULL) {
331                 BIO_printf(bio_err, "ERROR: Memory allocation\n");
332                 break;           /* Error */
333             }
334             oid_size = n + 1;
335         }
336         if (OBJ_obj2txt(oid_buf, oid_size, obj, 1) < 0)
337             break;               /* Error */
338         if (ln == NULL || strcmp(sn, ln) == 0)
339             BIO_printf(bio_out, "%s = %s\n", sn, oid_buf);
340         else
341             BIO_printf(bio_out, "%s = %s, %s\n", sn, ln, oid_buf);
342     }
343
344     OPENSSL_free(oid_buf);
345 }
346
347 static void list_options_for_command(const char *command)
348 {
349     const FUNCTION *fp;
350     const OPTIONS *o;
351
352     for (fp = functions; fp->name != NULL; fp++)
353         if (strcmp(fp->name, command) == 0)
354             break;
355     if (fp->name == NULL) {
356         BIO_printf(bio_err, "Invalid command '%s'; type \"help\" for a list.\n",
357                 command);
358         return;
359     }
360
361     if ((o = fp->help) == NULL)
362         return;
363
364     for ( ; o->name != NULL; o++) {
365         char c = o->valtype;
366
367         if (o->name == OPT_HELP_STR
368                 || o->name == OPT_MORE_STR
369                 || o->name == OPT_SECTION_STR
370                 || o->name[0] == '\0')
371             continue;
372         BIO_printf(bio_out, "%s %c\n", o->name, c == '\0' ? '-' : c);
373     }
374     /* Always output the -- marker since it is sometimes documented. */
375     BIO_printf(bio_out, "- -\n");
376 }
377
378 static void list_type(FUNC_TYPE ft, int one)
379 {
380     FUNCTION *fp;
381     int i = 0;
382     DISPLAY_COLUMNS dc;
383
384     memset(&dc, 0, sizeof(dc));
385     if (!one)
386         calculate_columns(functions, &dc);
387
388     for (fp = functions; fp->name != NULL; fp++) {
389         if (fp->type != ft)
390             continue;
391         if (one) {
392             BIO_printf(bio_out, "%s\n", fp->name);
393         } else {
394             if (i % dc.columns == 0 && i > 0)
395                 BIO_printf(bio_out, "\n");
396             BIO_printf(bio_out, "%-*s", dc.width, fp->name);
397             i++;
398         }
399     }
400     if (!one)
401         BIO_printf(bio_out, "\n\n");
402 }
403
404 static void list_pkey(void)
405 {
406     int i;
407
408     for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
409         const EVP_PKEY_ASN1_METHOD *ameth;
410         int pkey_id, pkey_base_id, pkey_flags;
411         const char *pinfo, *pem_str;
412         ameth = EVP_PKEY_asn1_get0(i);
413         EVP_PKEY_asn1_get0_info(&pkey_id, &pkey_base_id, &pkey_flags,
414                                 &pinfo, &pem_str, ameth);
415         if (pkey_flags & ASN1_PKEY_ALIAS) {
416             BIO_printf(bio_out, "Name: %s\n", OBJ_nid2ln(pkey_id));
417             BIO_printf(bio_out, "\tAlias for: %s\n",
418                        OBJ_nid2ln(pkey_base_id));
419         } else {
420             BIO_printf(bio_out, "Name: %s\n", pinfo);
421             BIO_printf(bio_out, "\tType: %s Algorithm\n",
422                        pkey_flags & ASN1_PKEY_DYNAMIC ?
423                        "External" : "Builtin");
424             BIO_printf(bio_out, "\tOID: %s\n", OBJ_nid2ln(pkey_id));
425             if (pem_str == NULL)
426                 pem_str = "(none)";
427             BIO_printf(bio_out, "\tPEM string: %s\n", pem_str);
428         }
429
430     }
431 }
432
433 static void list_pkey_meth(void)
434 {
435     size_t i;
436     size_t meth_count = EVP_PKEY_meth_get_count();
437
438     for (i = 0; i < meth_count; i++) {
439         const EVP_PKEY_METHOD *pmeth = EVP_PKEY_meth_get0(i);
440         int pkey_id, pkey_flags;
441
442         EVP_PKEY_meth_get0_info(&pkey_id, &pkey_flags, pmeth);
443         BIO_printf(bio_out, "%s\n", OBJ_nid2ln(pkey_id));
444         BIO_printf(bio_out, "\tType: %s Algorithm\n",
445                    pkey_flags & ASN1_PKEY_DYNAMIC ?  "External" : "Builtin");
446     }
447 }
448
449 static void list_engines(void)
450 {
451 #ifndef OPENSSL_NO_ENGINE
452     ENGINE *e;
453
454     BIO_puts(bio_out, "Engines:\n");
455     e = ENGINE_get_first();
456     while (e) {
457         BIO_printf(bio_out, "%s\n", ENGINE_get_id(e));
458         e = ENGINE_get_next(e);
459     }
460 #else
461     BIO_puts(bio_out, "Engine support is disabled.\n");
462 #endif
463 }
464
465 static void list_disabled(void)
466 {
467     BIO_puts(bio_out, "Disabled algorithms:\n");
468 #ifdef OPENSSL_NO_ARIA
469     BIO_puts(bio_out, "ARIA\n");
470 #endif
471 #ifdef OPENSSL_NO_BF
472     BIO_puts(bio_out, "BF\n");
473 #endif
474 #ifdef OPENSSL_NO_BLAKE2
475     BIO_puts(bio_out, "BLAKE2\n");
476 #endif
477 #ifdef OPENSSL_NO_CAMELLIA
478     BIO_puts(bio_out, "CAMELLIA\n");
479 #endif
480 #ifdef OPENSSL_NO_CAST
481     BIO_puts(bio_out, "CAST\n");
482 #endif
483 #ifdef OPENSSL_NO_CMAC
484     BIO_puts(bio_out, "CMAC\n");
485 #endif
486 #ifdef OPENSSL_NO_CMS
487     BIO_puts(bio_out, "CMS\n");
488 #endif
489 #ifdef OPENSSL_NO_COMP
490     BIO_puts(bio_out, "COMP\n");
491 #endif
492 #ifdef OPENSSL_NO_DES
493     BIO_puts(bio_out, "DES\n");
494 #endif
495 #ifdef OPENSSL_NO_DGRAM
496     BIO_puts(bio_out, "DGRAM\n");
497 #endif
498 #ifdef OPENSSL_NO_DH
499     BIO_puts(bio_out, "DH\n");
500 #endif
501 #ifdef OPENSSL_NO_DSA
502     BIO_puts(bio_out, "DSA\n");
503 #endif
504 #if defined(OPENSSL_NO_DTLS)
505     BIO_puts(bio_out, "DTLS\n");
506 #endif
507 #if defined(OPENSSL_NO_DTLS1)
508     BIO_puts(bio_out, "DTLS1\n");
509 #endif
510 #if defined(OPENSSL_NO_DTLS1_2)
511     BIO_puts(bio_out, "DTLS1_2\n");
512 #endif
513 #ifdef OPENSSL_NO_EC
514     BIO_puts(bio_out, "EC\n");
515 #endif
516 #ifdef OPENSSL_NO_EC2M
517     BIO_puts(bio_out, "EC2M\n");
518 #endif
519 #ifdef OPENSSL_NO_ENGINE
520     BIO_puts(bio_out, "ENGINE\n");
521 #endif
522 #ifdef OPENSSL_NO_GOST
523     BIO_puts(bio_out, "GOST\n");
524 #endif
525 #ifdef OPENSSL_NO_IDEA
526     BIO_puts(bio_out, "IDEA\n");
527 #endif
528 #ifdef OPENSSL_NO_MD2
529     BIO_puts(bio_out, "MD2\n");
530 #endif
531 #ifdef OPENSSL_NO_MD4
532     BIO_puts(bio_out, "MD4\n");
533 #endif
534 #ifdef OPENSSL_NO_MD5
535     BIO_puts(bio_out, "MD5\n");
536 #endif
537 #ifdef OPENSSL_NO_MDC2
538     BIO_puts(bio_out, "MDC2\n");
539 #endif
540 #ifdef OPENSSL_NO_OCB
541     BIO_puts(bio_out, "OCB\n");
542 #endif
543 #ifdef OPENSSL_NO_OCSP
544     BIO_puts(bio_out, "OCSP\n");
545 #endif
546 #ifdef OPENSSL_NO_PSK
547     BIO_puts(bio_out, "PSK\n");
548 #endif
549 #ifdef OPENSSL_NO_RC2
550     BIO_puts(bio_out, "RC2\n");
551 #endif
552 #ifdef OPENSSL_NO_RC4
553     BIO_puts(bio_out, "RC4\n");
554 #endif
555 #ifdef OPENSSL_NO_RC5
556     BIO_puts(bio_out, "RC5\n");
557 #endif
558 #ifdef OPENSSL_NO_RMD160
559     BIO_puts(bio_out, "RMD160\n");
560 #endif
561 #ifdef OPENSSL_NO_RSA
562     BIO_puts(bio_out, "RSA\n");
563 #endif
564 #ifdef OPENSSL_NO_SCRYPT
565     BIO_puts(bio_out, "SCRYPT\n");
566 #endif
567 #ifdef OPENSSL_NO_SCTP
568     BIO_puts(bio_out, "SCTP\n");
569 #endif
570 #ifdef OPENSSL_NO_SEED
571     BIO_puts(bio_out, "SEED\n");
572 #endif
573 #ifdef OPENSSL_NO_SM2
574     BIO_puts(bio_out, "SM2\n");
575 #endif
576 #ifdef OPENSSL_NO_SM3
577     BIO_puts(bio_out, "SM3\n");
578 #endif
579 #ifdef OPENSSL_NO_SM4
580     BIO_puts(bio_out, "SM4\n");
581 #endif
582 #ifdef OPENSSL_NO_SOCK
583     BIO_puts(bio_out, "SOCK\n");
584 #endif
585 #ifdef OPENSSL_NO_SRP
586     BIO_puts(bio_out, "SRP\n");
587 #endif
588 #ifdef OPENSSL_NO_SRTP
589     BIO_puts(bio_out, "SRTP\n");
590 #endif
591 #ifdef OPENSSL_NO_SSL3
592     BIO_puts(bio_out, "SSL3\n");
593 #endif
594 #ifdef OPENSSL_NO_TLS1
595     BIO_puts(bio_out, "TLS1\n");
596 #endif
597 #ifdef OPENSSL_NO_TLS1_1
598     BIO_puts(bio_out, "TLS1_1\n");
599 #endif
600 #ifdef OPENSSL_NO_TLS1_2
601     BIO_puts(bio_out, "TLS1_2\n");
602 #endif
603 #ifdef OPENSSL_NO_WHIRLPOOL
604     BIO_puts(bio_out, "WHIRLPOOL\n");
605 #endif
606 #ifndef ZLIB
607     BIO_puts(bio_out, "ZLIB\n");
608 #endif
609 }
610
611 /* Unified enum for help and list commands. */
612 typedef enum HELPLIST_CHOICE {
613     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ONE, OPT_VERBOSE,
614     OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS,
615     OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS,
616     OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_ENGINES, OPT_DISABLED,
617     OPT_KDF_ALGORITHMS, OPT_MISSING_HELP, OPT_OBJECTS
618 } HELPLIST_CHOICE;
619
620 const OPTIONS list_options[] = {
621
622     OPT_SECTION("General"),
623     {"help", OPT_HELP, '-', "Display this summary"},
624
625     OPT_SECTION("Output"),
626     {"1", OPT_ONE, '-', "List in one column"},
627     {"verbose", OPT_VERBOSE, '-', "Verbose listing"},
628     {"commands", OPT_COMMANDS, '-', "List of standard commands"},
629     {"digest-commands", OPT_DIGEST_COMMANDS, '-',
630      "List of message digest commands"},
631     {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-',
632      "List of message digest algorithms"},
633     {"kdf-algorithms", OPT_KDF_ALGORITHMS, '-',
634      "List of key derivation and pseudo random function algorithms"},
635     {"mac-algorithms", OPT_MAC_ALGORITHMS, '-',
636      "List of message authentication code algorithms"},
637     {"cipher-commands", OPT_CIPHER_COMMANDS, '-', "List of cipher commands"},
638     {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-',
639      "List of cipher algorithms"},
640     {"public-key-algorithms", OPT_PK_ALGORITHMS, '-',
641      "List of public key algorithms"},
642     {"public-key-methods", OPT_PK_METHOD, '-',
643      "List of public key methods"},
644     {"engines", OPT_ENGINES, '-',
645      "List of loaded engines"},
646     {"disabled", OPT_DISABLED, '-',
647      "List of disabled features"},
648     {"missing-help", OPT_MISSING_HELP, '-',
649      "List missing detailed help strings"},
650     {"options", OPT_OPTIONS, 's',
651      "List options for specified command"},
652     {"objects", OPT_OBJECTS, '-',
653      "List built in objects (OID<->name mappings)"},
654     {NULL}
655 };
656
657 int list_main(int argc, char **argv)
658 {
659     char *prog;
660     HELPLIST_CHOICE o;
661     int one = 0, done = 0;
662     struct {
663         unsigned int commands:1;
664         unsigned int digest_commands:1;
665         unsigned int digest_algorithms:1;
666         unsigned int kdf_algorithms:1;
667         unsigned int mac_algorithms:1;
668         unsigned int cipher_commands:1;
669         unsigned int cipher_algorithms:1;
670         unsigned int pk_algorithms:1;
671         unsigned int pk_method:1;
672         unsigned int engines:1;
673         unsigned int disabled:1;
674         unsigned int missing_help:1;
675         unsigned int objects:1;
676         unsigned int options:1;
677     } todo = { 0, };
678
679     verbose = 0;                 /* Clear a possible previous call */
680
681     prog = opt_init(argc, argv, list_options);
682     while ((o = opt_next()) != OPT_EOF) {
683         switch (o) {
684         case OPT_EOF:  /* Never hit, but suppresses warning */
685         case OPT_ERR:
686 opthelp:
687             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
688             return 1;
689         case OPT_HELP:
690             opt_help(list_options);
691             break;
692         case OPT_ONE:
693             one = 1;
694             break;
695         case OPT_COMMANDS:
696             todo.commands = 1;
697             break;
698         case OPT_DIGEST_COMMANDS:
699             todo.digest_commands = 1;
700             break;
701         case OPT_DIGEST_ALGORITHMS:
702             todo.digest_algorithms = 1;
703             break;
704         case OPT_KDF_ALGORITHMS:
705             todo.kdf_algorithms = 1;
706             break;
707         case OPT_MAC_ALGORITHMS:
708             todo.mac_algorithms = 1;
709             break;
710         case OPT_CIPHER_COMMANDS:
711             todo.cipher_commands = 1;
712             break;
713         case OPT_CIPHER_ALGORITHMS:
714             todo.cipher_algorithms = 1;
715             break;
716         case OPT_PK_ALGORITHMS:
717             todo.pk_algorithms = 1;
718             break;
719         case OPT_PK_METHOD:
720             todo.pk_method = 1;
721             break;
722         case OPT_ENGINES:
723             todo.engines = 1;
724             break;
725         case OPT_DISABLED:
726             todo.disabled = 1;
727             break;
728         case OPT_MISSING_HELP:
729             todo.missing_help = 1;
730             break;
731         case OPT_OBJECTS:
732             todo.objects = 1;
733             break;
734         case OPT_OPTIONS:
735             list_options_for_command(opt_arg());
736             break;
737         case OPT_VERBOSE:
738             verbose = 1;
739             break;
740         }
741         done = 1;
742     }
743     if (opt_num_rest() != 0) {
744         BIO_printf(bio_err, "Extra arguments given.\n");
745         goto opthelp;
746     }
747
748     if (todo.commands)
749         list_type(FT_general, one);
750     if (todo.digest_commands)
751         list_type(FT_md, one);
752     if (todo.digest_algorithms)
753         list_digests();
754     if (todo.kdf_algorithms)
755         list_kdfs();
756     if (todo.mac_algorithms)
757         list_macs();
758     if (todo.cipher_commands)
759         list_type(FT_cipher, one);
760     if (todo.cipher_algorithms)
761         list_ciphers();
762     if (todo.pk_algorithms)
763         list_pkey();
764     if (todo.pk_method)
765         list_pkey_meth();
766     if (todo.engines)
767         list_engines();
768     if (todo.disabled)
769         list_disabled();
770     if (todo.missing_help)
771         list_missing_help();
772     if (todo.objects)
773         list_objects();
774
775     if (!done)
776         goto opthelp;
777
778     return 0;
779 }