]>
Commit | Line | Data |
---|---|---|
753149d9 RL |
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> | |
b8441adb RL |
13 | #include <openssl/provider.h> |
14 | #include <openssl/safestack.h> | |
753149d9 RL |
15 | #include "apps.h" |
16 | #include "progs.h" | |
17 | #include "opt.h" | |
18 | ||
19 | static void list_cipher_fn(const EVP_CIPHER *c, | |
20 | const char *from, const char *to, void *arg) | |
21 | { | |
22 | if (c != NULL) { | |
b8441adb | 23 | BIO_printf(arg, " %s\n", EVP_CIPHER_name(c)); |
753149d9 RL |
24 | } else { |
25 | if (from == NULL) | |
26 | from = "<undefined>"; | |
27 | if (to == NULL) | |
28 | to = "<undefined>"; | |
b8441adb RL |
29 | BIO_printf(arg, " %s => %s\n", from, to); |
30 | } | |
31 | } | |
32 | ||
33 | DEFINE_STACK_OF(EVP_CIPHER) | |
34 | static int cipher_cmp(const EVP_CIPHER * const *a, | |
35 | const EVP_CIPHER * const *b) | |
36 | { | |
37 | int ret = strcasecmp(EVP_CIPHER_name(*a), EVP_CIPHER_name(*b)); | |
38 | ||
39 | if (ret == 0) | |
40 | ret = strcmp(OSSL_PROVIDER_name(EVP_CIPHER_provider(*a)), | |
41 | OSSL_PROVIDER_name(EVP_CIPHER_provider(*b))); | |
42 | ||
43 | return ret; | |
44 | } | |
45 | ||
46 | static void collect_ciphers(EVP_CIPHER *cipher, void *stack) | |
47 | { | |
48 | STACK_OF(EVP_CIPHER) *cipher_stack = stack; | |
49 | ||
50 | sk_EVP_CIPHER_push(cipher_stack, cipher); | |
51 | EVP_CIPHER_up_ref(cipher); | |
52 | } | |
53 | ||
54 | static void list_ciphers(void) | |
55 | { | |
56 | STACK_OF(EVP_CIPHER) *ciphers = sk_EVP_CIPHER_new(cipher_cmp); | |
57 | int i; | |
58 | ||
59 | BIO_printf(bio_out, "Legacy:\n"); | |
60 | EVP_CIPHER_do_all_sorted(list_cipher_fn, bio_out); | |
61 | ||
62 | BIO_printf(bio_out, "Provided:\n"); | |
63 | EVP_CIPHER_do_all_ex(NULL, collect_ciphers, ciphers); | |
64 | sk_EVP_CIPHER_sort(ciphers); | |
65 | for (i = 0; i < sk_EVP_CIPHER_num(ciphers); i++) { | |
66 | const EVP_CIPHER *c = sk_EVP_CIPHER_value(ciphers, i); | |
67 | ||
68 | BIO_printf(bio_out, " %s", EVP_CIPHER_name(c)); | |
69 | BIO_printf(bio_out, " @ %s\n", | |
70 | OSSL_PROVIDER_name(EVP_CIPHER_provider(c))); | |
753149d9 | 71 | } |
b8441adb | 72 | sk_EVP_CIPHER_pop_free(ciphers, EVP_CIPHER_meth_free); |
753149d9 RL |
73 | } |
74 | ||
75 | static void list_md_fn(const EVP_MD *m, | |
76 | const char *from, const char *to, void *arg) | |
77 | { | |
78 | if (m != NULL) { | |
b8441adb | 79 | BIO_printf(arg, " %s\n", EVP_MD_name(m)); |
753149d9 RL |
80 | } else { |
81 | if (from == NULL) | |
82 | from = "<undefined>"; | |
83 | if (to == NULL) | |
84 | to = "<undefined>"; | |
b8441adb RL |
85 | BIO_printf((BIO *)arg, " %s => %s\n", from, to); |
86 | } | |
87 | } | |
88 | ||
89 | DEFINE_STACK_OF(EVP_MD) | |
90 | static int md_cmp(const EVP_MD * const *a, const EVP_MD * const *b) | |
91 | { | |
92 | int ret = strcasecmp(EVP_MD_name(*a), EVP_MD_name(*b)); | |
93 | ||
94 | if (ret == 0) | |
95 | ret = strcmp(OSSL_PROVIDER_name(EVP_MD_provider(*a)), | |
96 | OSSL_PROVIDER_name(EVP_MD_provider(*b))); | |
97 | ||
98 | return ret; | |
99 | } | |
100 | ||
101 | static void collect_digests(EVP_MD *md, void *stack) | |
102 | { | |
103 | STACK_OF(EVP_MD) *digest_stack = stack; | |
104 | ||
105 | sk_EVP_MD_push(digest_stack, md); | |
106 | EVP_MD_up_ref(md); | |
107 | } | |
108 | ||
109 | static void list_digests(void) | |
110 | { | |
111 | STACK_OF(EVP_MD) *digests = sk_EVP_MD_new(md_cmp); | |
112 | int i; | |
113 | ||
114 | BIO_printf(bio_out, "Legacy:\n"); | |
115 | EVP_MD_do_all_sorted(list_md_fn, bio_out); | |
116 | ||
117 | BIO_printf(bio_out, "Provided:\n"); | |
118 | EVP_MD_do_all_ex(NULL, collect_digests, digests); | |
119 | sk_EVP_MD_sort(digests); | |
120 | for (i = 0; i < sk_EVP_MD_num(digests); i++) { | |
121 | const EVP_MD *c = sk_EVP_MD_value(digests, i); | |
122 | ||
123 | BIO_printf(bio_out, " %s", EVP_MD_name(c)); | |
124 | BIO_printf(bio_out, " @ %s\n", | |
125 | OSSL_PROVIDER_name(EVP_MD_provider(c))); | |
753149d9 | 126 | } |
b8441adb | 127 | sk_EVP_MD_pop_free(digests, EVP_MD_meth_free); |
753149d9 RL |
128 | } |
129 | ||
130 | static void list_mac_fn(const EVP_MAC *m, | |
131 | const char *from, const char *to, void *arg) | |
132 | { | |
133 | if (m != NULL) { | |
134 | BIO_printf(arg, "%s\n", EVP_MAC_name(m)); | |
135 | } else { | |
136 | if (from == NULL) | |
137 | from = "<undefined>"; | |
138 | if (to == NULL) | |
139 | to = "<undefined>"; | |
140 | BIO_printf(arg, "%s => %s\n", from, to); | |
141 | } | |
142 | } | |
143 | ||
144 | static void list_missing_help(void) | |
145 | { | |
146 | const FUNCTION *fp; | |
147 | const OPTIONS *o; | |
148 | ||
149 | for (fp = functions; fp->name != NULL; fp++) { | |
150 | if ((o = fp->help) != NULL) { | |
151 | /* If there is help, list what flags are not documented. */ | |
152 | for ( ; o->name != NULL; o++) { | |
153 | if (o->helpstr == NULL) | |
154 | BIO_printf(bio_out, "%s %s\n", fp->name, o->name); | |
155 | } | |
156 | } else if (fp->func != dgst_main) { | |
157 | /* If not aliased to the dgst command, */ | |
158 | BIO_printf(bio_out, "%s *\n", fp->name); | |
159 | } | |
160 | } | |
161 | } | |
162 | ||
163 | static void list_objects(void) | |
164 | { | |
165 | int max_nid = OBJ_new_nid(0); | |
166 | int i; | |
167 | char *oid_buf = NULL; | |
168 | int oid_size = 0; | |
169 | ||
170 | /* Skip 0, since that's NID_undef */ | |
171 | for (i = 1; i < max_nid; i++) { | |
172 | const ASN1_OBJECT *obj = OBJ_nid2obj(i); | |
173 | const char *sn = OBJ_nid2sn(i); | |
174 | const char *ln = OBJ_nid2ln(i); | |
175 | int n = 0; | |
176 | ||
177 | /* | |
178 | * If one of the retrieved objects somehow generated an error, | |
179 | * we ignore it. The check for NID_undef below will detect the | |
180 | * error and simply skip to the next NID. | |
181 | */ | |
182 | ERR_clear_error(); | |
183 | ||
184 | if (OBJ_obj2nid(obj) == NID_undef) | |
185 | continue; | |
186 | ||
187 | if ((n = OBJ_obj2txt(NULL, 0, obj, 1)) == 0) { | |
188 | BIO_printf(bio_out, "# None-OID object: %s, %s\n", sn, ln); | |
189 | continue; | |
190 | } | |
191 | if (n < 0) | |
192 | break; /* Error */ | |
193 | ||
194 | if (n > oid_size) { | |
195 | oid_buf = OPENSSL_realloc(oid_buf, n + 1); | |
196 | if (oid_buf == NULL) { | |
197 | BIO_printf(bio_err, "ERROR: Memory allocation\n"); | |
198 | break; /* Error */ | |
199 | } | |
200 | oid_size = n + 1; | |
201 | } | |
202 | if (OBJ_obj2txt(oid_buf, oid_size, obj, 1) < 0) | |
203 | break; /* Error */ | |
204 | if (ln == NULL || strcmp(sn, ln) == 0) | |
205 | BIO_printf(bio_out, "%s = %s\n", sn, oid_buf); | |
206 | else | |
207 | BIO_printf(bio_out, "%s = %s, %s\n", sn, ln, oid_buf); | |
208 | } | |
209 | ||
210 | OPENSSL_free(oid_buf); | |
211 | } | |
212 | ||
213 | static void list_options_for_command(const char *command) | |
214 | { | |
215 | const FUNCTION *fp; | |
216 | const OPTIONS *o; | |
217 | ||
218 | for (fp = functions; fp->name != NULL; fp++) | |
219 | if (strcmp(fp->name, command) == 0) | |
220 | break; | |
221 | if (fp->name == NULL) { | |
222 | BIO_printf(bio_err, "Invalid command '%s'; type \"help\" for a list.\n", | |
223 | command); | |
224 | return; | |
225 | } | |
226 | ||
227 | if ((o = fp->help) == NULL) | |
228 | return; | |
229 | ||
230 | for ( ; o->name != NULL; o++) { | |
231 | if (o->name == OPT_HELP_STR | |
232 | || o->name == OPT_MORE_STR | |
233 | || o->name[0] == '\0') | |
234 | continue; | |
235 | BIO_printf(bio_out, "%s %c\n", o->name, o->valtype); | |
236 | } | |
237 | } | |
238 | ||
239 | static void list_type(FUNC_TYPE ft, int one) | |
240 | { | |
241 | FUNCTION *fp; | |
242 | int i = 0; | |
243 | DISPLAY_COLUMNS dc; | |
244 | ||
245 | memset(&dc, 0, sizeof(dc)); | |
246 | if (!one) | |
247 | calculate_columns(functions, &dc); | |
248 | ||
249 | for (fp = functions; fp->name != NULL; fp++) { | |
250 | if (fp->type != ft) | |
251 | continue; | |
252 | if (one) { | |
253 | BIO_printf(bio_out, "%s\n", fp->name); | |
254 | } else { | |
255 | if (i % dc.columns == 0 && i > 0) | |
256 | BIO_printf(bio_out, "\n"); | |
257 | BIO_printf(bio_out, "%-*s", dc.width, fp->name); | |
258 | i++; | |
259 | } | |
260 | } | |
261 | if (!one) | |
262 | BIO_printf(bio_out, "\n\n"); | |
263 | } | |
264 | ||
265 | static void list_pkey(void) | |
266 | { | |
267 | int i; | |
268 | ||
269 | for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) { | |
270 | const EVP_PKEY_ASN1_METHOD *ameth; | |
271 | int pkey_id, pkey_base_id, pkey_flags; | |
272 | const char *pinfo, *pem_str; | |
273 | ameth = EVP_PKEY_asn1_get0(i); | |
274 | EVP_PKEY_asn1_get0_info(&pkey_id, &pkey_base_id, &pkey_flags, | |
275 | &pinfo, &pem_str, ameth); | |
276 | if (pkey_flags & ASN1_PKEY_ALIAS) { | |
277 | BIO_printf(bio_out, "Name: %s\n", OBJ_nid2ln(pkey_id)); | |
278 | BIO_printf(bio_out, "\tAlias for: %s\n", | |
279 | OBJ_nid2ln(pkey_base_id)); | |
280 | } else { | |
281 | BIO_printf(bio_out, "Name: %s\n", pinfo); | |
282 | BIO_printf(bio_out, "\tType: %s Algorithm\n", | |
283 | pkey_flags & ASN1_PKEY_DYNAMIC ? | |
284 | "External" : "Builtin"); | |
285 | BIO_printf(bio_out, "\tOID: %s\n", OBJ_nid2ln(pkey_id)); | |
286 | if (pem_str == NULL) | |
287 | pem_str = "(none)"; | |
288 | BIO_printf(bio_out, "\tPEM string: %s\n", pem_str); | |
289 | } | |
290 | ||
291 | } | |
292 | } | |
293 | ||
294 | static void list_pkey_meth(void) | |
295 | { | |
296 | size_t i; | |
297 | size_t meth_count = EVP_PKEY_meth_get_count(); | |
298 | ||
299 | for (i = 0; i < meth_count; i++) { | |
300 | const EVP_PKEY_METHOD *pmeth = EVP_PKEY_meth_get0(i); | |
301 | int pkey_id, pkey_flags; | |
302 | ||
303 | EVP_PKEY_meth_get0_info(&pkey_id, &pkey_flags, pmeth); | |
304 | BIO_printf(bio_out, "%s\n", OBJ_nid2ln(pkey_id)); | |
305 | BIO_printf(bio_out, "\tType: %s Algorithm\n", | |
306 | pkey_flags & ASN1_PKEY_DYNAMIC ? "External" : "Builtin"); | |
307 | } | |
308 | } | |
309 | ||
310 | static void list_engines(void) | |
311 | { | |
312 | #ifndef OPENSSL_NO_ENGINE | |
313 | ENGINE *e; | |
314 | ||
315 | BIO_puts(bio_out, "Engines:\n"); | |
316 | e = ENGINE_get_first(); | |
317 | while (e) { | |
318 | BIO_printf(bio_out, "%s\n", ENGINE_get_id(e)); | |
319 | e = ENGINE_get_next(e); | |
320 | } | |
321 | #else | |
322 | BIO_puts(bio_out, "Engine support is disabled.\n"); | |
323 | #endif | |
324 | } | |
325 | ||
326 | static void list_disabled(void) | |
327 | { | |
328 | BIO_puts(bio_out, "Disabled algorithms:\n"); | |
329 | #ifdef OPENSSL_NO_ARIA | |
330 | BIO_puts(bio_out, "ARIA\n"); | |
331 | #endif | |
332 | #ifdef OPENSSL_NO_BF | |
333 | BIO_puts(bio_out, "BF\n"); | |
334 | #endif | |
335 | #ifdef OPENSSL_NO_BLAKE2 | |
336 | BIO_puts(bio_out, "BLAKE2\n"); | |
337 | #endif | |
338 | #ifdef OPENSSL_NO_CAMELLIA | |
339 | BIO_puts(bio_out, "CAMELLIA\n"); | |
340 | #endif | |
341 | #ifdef OPENSSL_NO_CAST | |
342 | BIO_puts(bio_out, "CAST\n"); | |
343 | #endif | |
344 | #ifdef OPENSSL_NO_CMAC | |
345 | BIO_puts(bio_out, "CMAC\n"); | |
346 | #endif | |
347 | #ifdef OPENSSL_NO_CMS | |
348 | BIO_puts(bio_out, "CMS\n"); | |
349 | #endif | |
350 | #ifdef OPENSSL_NO_COMP | |
351 | BIO_puts(bio_out, "COMP\n"); | |
352 | #endif | |
353 | #ifdef OPENSSL_NO_DES | |
354 | BIO_puts(bio_out, "DES\n"); | |
355 | #endif | |
356 | #ifdef OPENSSL_NO_DGRAM | |
357 | BIO_puts(bio_out, "DGRAM\n"); | |
358 | #endif | |
359 | #ifdef OPENSSL_NO_DH | |
360 | BIO_puts(bio_out, "DH\n"); | |
361 | #endif | |
362 | #ifdef OPENSSL_NO_DSA | |
363 | BIO_puts(bio_out, "DSA\n"); | |
364 | #endif | |
365 | #if defined(OPENSSL_NO_DTLS) | |
366 | BIO_puts(bio_out, "DTLS\n"); | |
367 | #endif | |
368 | #if defined(OPENSSL_NO_DTLS1) | |
369 | BIO_puts(bio_out, "DTLS1\n"); | |
370 | #endif | |
371 | #if defined(OPENSSL_NO_DTLS1_2) | |
372 | BIO_puts(bio_out, "DTLS1_2\n"); | |
373 | #endif | |
374 | #ifdef OPENSSL_NO_EC | |
375 | BIO_puts(bio_out, "EC\n"); | |
376 | #endif | |
377 | #ifdef OPENSSL_NO_EC2M | |
378 | BIO_puts(bio_out, "EC2M\n"); | |
379 | #endif | |
380 | #ifdef OPENSSL_NO_ENGINE | |
381 | BIO_puts(bio_out, "ENGINE\n"); | |
382 | #endif | |
383 | #ifdef OPENSSL_NO_GOST | |
384 | BIO_puts(bio_out, "GOST\n"); | |
385 | #endif | |
386 | #ifdef OPENSSL_NO_IDEA | |
387 | BIO_puts(bio_out, "IDEA\n"); | |
388 | #endif | |
389 | #ifdef OPENSSL_NO_MD2 | |
390 | BIO_puts(bio_out, "MD2\n"); | |
391 | #endif | |
392 | #ifdef OPENSSL_NO_MD4 | |
393 | BIO_puts(bio_out, "MD4\n"); | |
394 | #endif | |
395 | #ifdef OPENSSL_NO_MD5 | |
396 | BIO_puts(bio_out, "MD5\n"); | |
397 | #endif | |
398 | #ifdef OPENSSL_NO_MDC2 | |
399 | BIO_puts(bio_out, "MDC2\n"); | |
400 | #endif | |
401 | #ifdef OPENSSL_NO_OCB | |
402 | BIO_puts(bio_out, "OCB\n"); | |
403 | #endif | |
404 | #ifdef OPENSSL_NO_OCSP | |
405 | BIO_puts(bio_out, "OCSP\n"); | |
406 | #endif | |
407 | #ifdef OPENSSL_NO_PSK | |
408 | BIO_puts(bio_out, "PSK\n"); | |
409 | #endif | |
410 | #ifdef OPENSSL_NO_RC2 | |
411 | BIO_puts(bio_out, "RC2\n"); | |
412 | #endif | |
413 | #ifdef OPENSSL_NO_RC4 | |
414 | BIO_puts(bio_out, "RC4\n"); | |
415 | #endif | |
416 | #ifdef OPENSSL_NO_RC5 | |
417 | BIO_puts(bio_out, "RC5\n"); | |
418 | #endif | |
419 | #ifdef OPENSSL_NO_RMD160 | |
420 | BIO_puts(bio_out, "RMD160\n"); | |
421 | #endif | |
422 | #ifdef OPENSSL_NO_RSA | |
423 | BIO_puts(bio_out, "RSA\n"); | |
424 | #endif | |
425 | #ifdef OPENSSL_NO_SCRYPT | |
426 | BIO_puts(bio_out, "SCRYPT\n"); | |
427 | #endif | |
428 | #ifdef OPENSSL_NO_SCTP | |
429 | BIO_puts(bio_out, "SCTP\n"); | |
430 | #endif | |
431 | #ifdef OPENSSL_NO_SEED | |
432 | BIO_puts(bio_out, "SEED\n"); | |
433 | #endif | |
434 | #ifdef OPENSSL_NO_SM2 | |
435 | BIO_puts(bio_out, "SM2\n"); | |
436 | #endif | |
437 | #ifdef OPENSSL_NO_SM3 | |
438 | BIO_puts(bio_out, "SM3\n"); | |
439 | #endif | |
440 | #ifdef OPENSSL_NO_SM4 | |
441 | BIO_puts(bio_out, "SM4\n"); | |
442 | #endif | |
443 | #ifdef OPENSSL_NO_SOCK | |
444 | BIO_puts(bio_out, "SOCK\n"); | |
445 | #endif | |
446 | #ifdef OPENSSL_NO_SRP | |
447 | BIO_puts(bio_out, "SRP\n"); | |
448 | #endif | |
449 | #ifdef OPENSSL_NO_SRTP | |
450 | BIO_puts(bio_out, "SRTP\n"); | |
451 | #endif | |
452 | #ifdef OPENSSL_NO_SSL3 | |
453 | BIO_puts(bio_out, "SSL3\n"); | |
454 | #endif | |
455 | #ifdef OPENSSL_NO_TLS1 | |
456 | BIO_puts(bio_out, "TLS1\n"); | |
457 | #endif | |
458 | #ifdef OPENSSL_NO_TLS1_1 | |
459 | BIO_puts(bio_out, "TLS1_1\n"); | |
460 | #endif | |
461 | #ifdef OPENSSL_NO_TLS1_2 | |
462 | BIO_puts(bio_out, "TLS1_2\n"); | |
463 | #endif | |
464 | #ifdef OPENSSL_NO_WHIRLPOOL | |
465 | BIO_puts(bio_out, "WHIRLPOOL\n"); | |
466 | #endif | |
467 | #ifndef ZLIB | |
468 | BIO_puts(bio_out, "ZLIB\n"); | |
469 | #endif | |
470 | } | |
471 | ||
472 | /* Unified enum for help and list commands. */ | |
473 | typedef enum HELPLIST_CHOICE { | |
474 | OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ONE, | |
475 | OPT_COMMANDS, OPT_DIGEST_COMMANDS, OPT_MAC_ALGORITHMS, OPT_OPTIONS, | |
476 | OPT_DIGEST_ALGORITHMS, OPT_CIPHER_COMMANDS, OPT_CIPHER_ALGORITHMS, | |
477 | OPT_PK_ALGORITHMS, OPT_PK_METHOD, OPT_ENGINES, OPT_DISABLED, | |
478 | OPT_MISSING_HELP, OPT_OBJECTS | |
479 | } HELPLIST_CHOICE; | |
480 | ||
481 | const OPTIONS list_options[] = { | |
482 | {"help", OPT_HELP, '-', "Display this summary"}, | |
483 | {"1", OPT_ONE, '-', "List in one column"}, | |
484 | {"commands", OPT_COMMANDS, '-', "List of standard commands"}, | |
485 | {"digest-commands", OPT_DIGEST_COMMANDS, '-', | |
486 | "List of message digest commands"}, | |
487 | {"digest-algorithms", OPT_DIGEST_ALGORITHMS, '-', | |
488 | "List of message digest algorithms"}, | |
489 | {"mac-algorithms", OPT_MAC_ALGORITHMS, '-', | |
490 | "List of message authentication code algorithms"}, | |
491 | {"cipher-commands", OPT_CIPHER_COMMANDS, '-', "List of cipher commands"}, | |
492 | {"cipher-algorithms", OPT_CIPHER_ALGORITHMS, '-', | |
493 | "List of cipher algorithms"}, | |
494 | {"public-key-algorithms", OPT_PK_ALGORITHMS, '-', | |
495 | "List of public key algorithms"}, | |
496 | {"public-key-methods", OPT_PK_METHOD, '-', | |
497 | "List of public key methods"}, | |
498 | {"engines", OPT_ENGINES, '-', | |
499 | "List of loaded engines"}, | |
500 | {"disabled", OPT_DISABLED, '-', | |
501 | "List of disabled features"}, | |
502 | {"missing-help", OPT_MISSING_HELP, '-', | |
503 | "List missing detailed help strings"}, | |
504 | {"options", OPT_OPTIONS, 's', | |
505 | "List options for specified command"}, | |
506 | {"objects", OPT_OBJECTS, '-', | |
507 | "List built in objects (OID<->name mappings)"}, | |
508 | {NULL} | |
509 | }; | |
510 | ||
511 | int list_main(int argc, char **argv) | |
512 | { | |
513 | char *prog; | |
514 | HELPLIST_CHOICE o; | |
515 | int one = 0, done = 0; | |
516 | ||
517 | prog = opt_init(argc, argv, list_options); | |
518 | while ((o = opt_next()) != OPT_EOF) { | |
519 | switch (o) { | |
520 | case OPT_EOF: /* Never hit, but suppresses warning */ | |
521 | case OPT_ERR: | |
522 | opthelp: | |
523 | BIO_printf(bio_err, "%s: Use -help for summary.\n", prog); | |
524 | return 1; | |
525 | case OPT_HELP: | |
526 | opt_help(list_options); | |
527 | break; | |
528 | case OPT_ONE: | |
529 | one = 1; | |
530 | break; | |
531 | case OPT_COMMANDS: | |
532 | list_type(FT_general, one); | |
533 | break; | |
534 | case OPT_DIGEST_COMMANDS: | |
535 | list_type(FT_md, one); | |
536 | break; | |
537 | case OPT_DIGEST_ALGORITHMS: | |
b8441adb | 538 | list_digests(); |
753149d9 RL |
539 | break; |
540 | case OPT_MAC_ALGORITHMS: | |
541 | EVP_MAC_do_all_sorted(list_mac_fn, bio_out); | |
542 | break; | |
543 | case OPT_CIPHER_COMMANDS: | |
544 | list_type(FT_cipher, one); | |
545 | break; | |
546 | case OPT_CIPHER_ALGORITHMS: | |
b8441adb | 547 | list_ciphers(); |
753149d9 RL |
548 | break; |
549 | case OPT_PK_ALGORITHMS: | |
550 | list_pkey(); | |
551 | break; | |
552 | case OPT_PK_METHOD: | |
553 | list_pkey_meth(); | |
554 | break; | |
555 | case OPT_ENGINES: | |
556 | list_engines(); | |
557 | break; | |
558 | case OPT_DISABLED: | |
559 | list_disabled(); | |
560 | break; | |
561 | case OPT_MISSING_HELP: | |
562 | list_missing_help(); | |
563 | break; | |
564 | case OPT_OBJECTS: | |
565 | list_objects(); | |
566 | break; | |
567 | case OPT_OPTIONS: | |
568 | list_options_for_command(opt_arg()); | |
569 | break; | |
570 | } | |
571 | done = 1; | |
572 | } | |
573 | if (opt_num_rest() != 0) { | |
574 | BIO_printf(bio_err, "Extra arguments given.\n"); | |
575 | goto opthelp; | |
576 | } | |
577 | ||
578 | if (!done) | |
579 | goto opthelp; | |
580 | ||
581 | return 0; | |
582 | } |