f8d5ecda14260ce05caa1cd024146a78cb0b2a58
[openssl.git] / test / ssl_test_ctx.c
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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
12 #include <openssl/e_os2.h>
13 #include <openssl/crypto.h>
14
15 #include "e_os.h"
16 #include "ssl_test_ctx.h"
17 #include "testutil.h"
18
19 static const int default_app_data_size = 256;
20 /* Default set to be as small as possible to exercise fragmentation. */
21 static const int default_max_fragment_size = 512;
22
23 static int parse_boolean(const char *value, int *result)
24 {
25     if (strcasecmp(value, "Yes") == 0) {
26         *result = 1;
27         return 1;
28     }
29     else if (strcasecmp(value, "No") == 0) {
30         *result = 0;
31         return 1;
32     }
33     return 0;
34 }
35
36 #define IMPLEMENT_SSL_TEST_BOOL_OPTION(struct_type, name, field)        \
37     static int parse_##name##_##field(struct_type *ctx, const char *value) \
38     {                                                                   \
39         return parse_boolean(value, &ctx->field);                       \
40     }
41
42 #define IMPLEMENT_SSL_TEST_STRING_OPTION(struct_type, name, field)      \
43     static int parse_##name##_##field(struct_type *ctx, const char *value) \
44     {                                                                   \
45         OPENSSL_free(ctx->field);                                       \
46         ctx->field = OPENSSL_strdup(value);                             \
47         TEST_check(ctx->field != NULL);                                 \
48         return 1;                                                       \
49     }
50
51 #define IMPLEMENT_SSL_TEST_INT_OPTION(struct_type, name, field)        \
52     static int parse_##name##_##field(struct_type *ctx, const char *value) \
53     {                                                                   \
54         ctx->field = atoi(value);                                       \
55         return 1;                                                       \
56     }
57
58 /* True enums and other test configuration values that map to an int. */
59 typedef struct {
60     const char *name;
61     int value;
62 } test_enum;
63
64
65 __owur static int parse_enum(const test_enum *enums, size_t num_enums,
66                              int *value, const char *name)
67 {
68     size_t i;
69     for (i = 0; i < num_enums; i++) {
70         if (strcmp(enums[i].name, name) == 0) {
71             *value = enums[i].value;
72             return 1;
73         }
74     }
75     return 0;
76 }
77
78 static const char *enum_name(const test_enum *enums, size_t num_enums,
79                              int value)
80 {
81     size_t i;
82     for (i = 0; i < num_enums; i++) {
83         if (enums[i].value == value) {
84             return enums[i].name;
85         }
86     }
87     return "InvalidValue";
88 }
89
90
91 /*******************/
92 /* ExpectedResult. */
93 /*******************/
94
95 static const test_enum ssl_test_results[] = {
96     {"Success", SSL_TEST_SUCCESS},
97     {"ServerFail", SSL_TEST_SERVER_FAIL},
98     {"ClientFail", SSL_TEST_CLIENT_FAIL},
99     {"InternalError", SSL_TEST_INTERNAL_ERROR},
100 };
101
102 __owur static int parse_expected_result(SSL_TEST_CTX *test_ctx, const char *value)
103 {
104     int ret_value;
105     if (!parse_enum(ssl_test_results, OSSL_NELEM(ssl_test_results),
106                     &ret_value, value)) {
107         return 0;
108     }
109     test_ctx->expected_result = ret_value;
110     return 1;
111 }
112
113 const char *ssl_test_result_name(ssl_test_result_t result)
114 {
115     return enum_name(ssl_test_results, OSSL_NELEM(ssl_test_results), result);
116 }
117
118 /**********************************************/
119 /* ExpectedClientAlert / ExpectedServerAlert. */
120 /**********************************************/
121
122 static const test_enum ssl_alerts[] = {
123     {"UnknownCA", SSL_AD_UNKNOWN_CA},
124     {"HandshakeFailure", SSL_AD_HANDSHAKE_FAILURE},
125     {"UnrecognizedName", SSL_AD_UNRECOGNIZED_NAME},
126     {"BadCertificate", SSL_AD_BAD_CERTIFICATE},
127     {"NoApplicationProtocol", SSL_AD_NO_APPLICATION_PROTOCOL},
128 };
129
130 __owur static int parse_alert(int *alert, const char *value)
131 {
132     return parse_enum(ssl_alerts, OSSL_NELEM(ssl_alerts), alert, value);
133 }
134
135 __owur static int parse_client_alert(SSL_TEST_CTX *test_ctx, const char *value)
136 {
137     return parse_alert(&test_ctx->expected_client_alert, value);
138 }
139
140 __owur static int parse_server_alert(SSL_TEST_CTX *test_ctx, const char *value)
141 {
142     return parse_alert(&test_ctx->expected_server_alert, value);
143 }
144
145 const char *ssl_alert_name(int alert)
146 {
147     return enum_name(ssl_alerts, OSSL_NELEM(ssl_alerts), alert);
148 }
149
150 /********************/
151 /* ExpectedProtocol */
152 /********************/
153
154 static const test_enum ssl_protocols[] = {
155      {"TLSv1.3", TLS1_3_VERSION},
156      {"TLSv1.2", TLS1_2_VERSION},
157      {"TLSv1.1", TLS1_1_VERSION},
158      {"TLSv1", TLS1_VERSION},
159      {"SSLv3", SSL3_VERSION},
160      {"DTLSv1", DTLS1_VERSION},
161      {"DTLSv1.2", DTLS1_2_VERSION},
162 };
163
164 __owur static int parse_protocol(SSL_TEST_CTX *test_ctx, const char *value)
165 {
166     return parse_enum(ssl_protocols, OSSL_NELEM(ssl_protocols),
167                       &test_ctx->expected_protocol, value);
168 }
169
170 const char *ssl_protocol_name(int protocol)
171 {
172     return enum_name(ssl_protocols, OSSL_NELEM(ssl_protocols), protocol);
173 }
174
175 /***********************/
176 /* VerifyCallback.     */
177 /***********************/
178
179 static const test_enum ssl_verify_callbacks[] = {
180     {"None", SSL_TEST_VERIFY_NONE},
181     {"AcceptAll", SSL_TEST_VERIFY_ACCEPT_ALL},
182     {"RejectAll", SSL_TEST_VERIFY_REJECT_ALL},
183 };
184
185 __owur static int parse_client_verify_callback(SSL_TEST_CLIENT_CONF *client_conf,
186                                                const char *value)
187 {
188     int ret_value;
189     if (!parse_enum(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
190                     &ret_value, value)) {
191         return 0;
192     }
193     client_conf->verify_callback = ret_value;
194     return 1;
195 }
196
197 const char *ssl_verify_callback_name(ssl_verify_callback_t callback)
198 {
199     return enum_name(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
200                      callback);
201 }
202
203 /**************/
204 /* ServerName */
205 /**************/
206
207 static const test_enum ssl_servername[] = {
208     {"None", SSL_TEST_SERVERNAME_NONE},
209     {"server1", SSL_TEST_SERVERNAME_SERVER1},
210     {"server2", SSL_TEST_SERVERNAME_SERVER2},
211     {"invalid", SSL_TEST_SERVERNAME_INVALID},
212 };
213
214 __owur static int parse_servername(SSL_TEST_CLIENT_CONF *client_conf,
215                                    const char *value)
216 {
217     int ret_value;
218     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
219                     &ret_value, value)) {
220         return 0;
221     }
222     client_conf->servername = ret_value;
223     return 1;
224 }
225
226 __owur static int parse_expected_servername(SSL_TEST_CTX *test_ctx,
227                                             const char *value)
228 {
229     int ret_value;
230     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
231                     &ret_value, value)) {
232         return 0;
233     }
234     test_ctx->expected_servername = ret_value;
235     return 1;
236 }
237
238 const char *ssl_servername_name(ssl_servername_t server)
239 {
240     return enum_name(ssl_servername, OSSL_NELEM(ssl_servername),
241                      server);
242 }
243
244 /**********************/
245 /* ServerNameCallback */
246 /**********************/
247
248 static const test_enum ssl_servername_callbacks[] = {
249     {"None", SSL_TEST_SERVERNAME_CB_NONE},
250     {"IgnoreMismatch", SSL_TEST_SERVERNAME_IGNORE_MISMATCH},
251     {"RejectMismatch", SSL_TEST_SERVERNAME_REJECT_MISMATCH},
252 };
253
254 __owur static int parse_servername_callback(SSL_TEST_SERVER_CONF *server_conf,
255                                             const char *value)
256 {
257     int ret_value;
258     if (!parse_enum(ssl_servername_callbacks,
259                     OSSL_NELEM(ssl_servername_callbacks), &ret_value, value)) {
260         return 0;
261     }
262     server_conf->servername_callback = ret_value;
263     return 1;
264 }
265
266 const char *ssl_servername_callback_name(ssl_servername_callback_t callback)
267 {
268     return enum_name(ssl_servername_callbacks,
269                      OSSL_NELEM(ssl_servername_callbacks), callback);
270 }
271
272 /*************************/
273 /* SessionTicketExpected */
274 /*************************/
275
276 static const test_enum ssl_session_ticket[] = {
277     {"Ignore", SSL_TEST_SESSION_TICKET_IGNORE},
278     {"Yes", SSL_TEST_SESSION_TICKET_YES},
279     {"No", SSL_TEST_SESSION_TICKET_NO},
280 };
281
282 __owur static int parse_session_ticket(SSL_TEST_CTX *test_ctx, const char *value)
283 {
284     int ret_value;
285     if (!parse_enum(ssl_session_ticket, OSSL_NELEM(ssl_session_ticket),
286                     &ret_value, value)) {
287         return 0;
288     }
289     test_ctx->session_ticket_expected = ret_value;
290     return 1;
291 }
292
293 const char *ssl_session_ticket_name(ssl_session_ticket_t server)
294 {
295     return enum_name(ssl_session_ticket,
296                      OSSL_NELEM(ssl_session_ticket),
297                      server);
298 }
299
300 /***********************/
301 /* Method              */
302 /***********************/
303
304 static const test_enum ssl_test_methods[] = {
305     {"TLS", SSL_TEST_METHOD_TLS},
306     {"DTLS", SSL_TEST_METHOD_DTLS},
307 };
308
309 __owur static int parse_test_method(SSL_TEST_CTX *test_ctx, const char *value)
310 {
311     int ret_value;
312     if (!parse_enum(ssl_test_methods, OSSL_NELEM(ssl_test_methods),
313                     &ret_value, value)) {
314         return 0;
315     }
316     test_ctx->method = ret_value;
317     return 1;
318 }
319
320 const char *ssl_test_method_name(ssl_test_method_t method)
321 {
322     return enum_name(ssl_test_methods, OSSL_NELEM(ssl_test_methods), method);
323 }
324
325 /************************************/
326 /* NPN and ALPN options             */
327 /************************************/
328
329 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, npn_protocols)
330 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, npn_protocols)
331 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CTX, test, expected_npn_protocol)
332 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, alpn_protocols)
333 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, alpn_protocols)
334 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CTX, test, expected_alpn_protocol)
335
336 /***********************/
337 /* Handshake mode      */
338 /***********************/
339
340 static const test_enum ssl_handshake_modes[] = {
341     {"Simple", SSL_TEST_HANDSHAKE_SIMPLE},
342     {"Resume", SSL_TEST_HANDSHAKE_RESUME},
343     {"RenegotiateServer", SSL_TEST_HANDSHAKE_RENEG_SERVER},
344     {"RenegotiateClient", SSL_TEST_HANDSHAKE_RENEG_CLIENT},
345 };
346
347 __owur static int parse_handshake_mode(SSL_TEST_CTX *test_ctx, const char *value)
348 {
349     int ret_value;
350     if (!parse_enum(ssl_handshake_modes, OSSL_NELEM(ssl_handshake_modes),
351                     &ret_value, value)) {
352         return 0;
353     }
354     test_ctx->handshake_mode = ret_value;
355     return 1;
356 }
357
358 const char *ssl_handshake_mode_name(ssl_handshake_mode_t mode)
359 {
360     return enum_name(ssl_handshake_modes, OSSL_NELEM(ssl_handshake_modes),
361                      mode);
362 }
363
364 /***********************/
365 /* CT Validation       */
366 /***********************/
367
368 static const test_enum ssl_ct_validation_modes[] = {
369     {"None", SSL_TEST_CT_VALIDATION_NONE},
370     {"Permissive", SSL_TEST_CT_VALIDATION_PERMISSIVE},
371     {"Strict", SSL_TEST_CT_VALIDATION_STRICT},
372 };
373
374 __owur static int parse_ct_validation(SSL_TEST_CLIENT_CONF *client_conf,
375                                       const char *value)
376 {
377     int ret_value;
378     if (!parse_enum(ssl_ct_validation_modes, OSSL_NELEM(ssl_ct_validation_modes),
379                     &ret_value, value)) {
380         return 0;
381     }
382     client_conf->ct_validation = ret_value;
383     return 1;
384 }
385
386 const char *ssl_ct_validation_name(ssl_ct_validation_t mode)
387 {
388     return enum_name(ssl_ct_validation_modes, OSSL_NELEM(ssl_ct_validation_modes),
389                      mode);
390 }
391
392 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_CTX, test, resumption_expected)
393 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_SERVER_CONF, server, broken_session_ticket)
394
395 /**************/
396 /* CertStatus */
397 /**************/
398
399 static const test_enum ssl_certstatus[] = {
400     {"None", SSL_TEST_CERT_STATUS_NONE},
401     {"GoodResponse", SSL_TEST_CERT_STATUS_GOOD_RESPONSE},
402     {"BadResponse", SSL_TEST_CERT_STATUS_BAD_RESPONSE}
403 };
404
405 __owur static int parse_certstatus(SSL_TEST_SERVER_CONF *server_conf,
406                                             const char *value)
407 {
408     int ret_value;
409     if (!parse_enum(ssl_certstatus, OSSL_NELEM(ssl_certstatus), &ret_value,
410                     value)) {
411         return 0;
412     }
413     server_conf->cert_status = ret_value;
414     return 1;
415 }
416
417 const char *ssl_certstatus_name(ssl_cert_status_t cert_status)
418 {
419     return enum_name(ssl_certstatus,
420                      OSSL_NELEM(ssl_certstatus), cert_status);
421 }
422
423 /***********************/
424 /* ApplicationData     */
425 /***********************/
426
427 IMPLEMENT_SSL_TEST_INT_OPTION(SSL_TEST_CTX, test, app_data_size)
428
429 /***********************/
430 /* MaxFragmentSize     */
431 /***********************/
432
433 IMPLEMENT_SSL_TEST_INT_OPTION(SSL_TEST_CTX, test, max_fragment_size)
434
435 /***********************/
436 /* Expected key types  */
437 /***********************/
438
439 __owur static int parse_expected_key_type(int *ptype, const char *value)
440 {
441     int nid;
442     const EVP_PKEY_ASN1_METHOD *ameth;
443
444     if (value == NULL)
445         return 0;
446     ameth = EVP_PKEY_asn1_find_str(NULL, value, -1);
447     if (ameth != NULL)
448         EVP_PKEY_asn1_get0_info(&nid, NULL, NULL, NULL, NULL, ameth);
449     else
450         nid = OBJ_sn2nid(value);
451     if (nid == NID_undef)
452         nid = OBJ_ln2nid(value);
453 #ifndef OPENSSL_NO_EC
454     if (nid == NID_undef)
455         nid = EC_curve_nist2nid(value);
456 #endif
457     if (nid == NID_undef)
458         return 0;
459     *ptype = nid;
460     return 1;
461 }
462
463 __owur static int parse_expected_tmp_key_type(SSL_TEST_CTX *test_ctx,
464                                               const char *value)
465 {
466     return parse_expected_key_type(&test_ctx->expected_tmp_key_type, value);
467 }
468
469 __owur static int parse_expected_server_cert_type(SSL_TEST_CTX *test_ctx,
470                                                   const char *value)
471 {
472     return parse_expected_key_type(&test_ctx->expected_server_cert_type,
473                                    value);
474 }
475
476 __owur static int parse_expected_client_cert_type(SSL_TEST_CTX *test_ctx,
477                                                   const char *value)
478 {
479     return parse_expected_key_type(&test_ctx->expected_client_cert_type,
480                                    value);
481 }
482
483 /*************************************************************/
484 /* Known test options and their corresponding parse methods. */
485 /*************************************************************/
486
487 /* Top-level options. */
488 typedef struct {
489     const char *name;
490     int (*parse)(SSL_TEST_CTX *test_ctx, const char *value);
491 } ssl_test_ctx_option;
492
493 static const ssl_test_ctx_option ssl_test_ctx_options[] = {
494     { "ExpectedResult", &parse_expected_result },
495     { "ExpectedClientAlert", &parse_client_alert },
496     { "ExpectedServerAlert", &parse_server_alert },
497     { "ExpectedProtocol", &parse_protocol },
498     { "ExpectedServerName", &parse_expected_servername },
499     { "SessionTicketExpected", &parse_session_ticket },
500     { "Method", &parse_test_method },
501     { "ExpectedNPNProtocol", &parse_test_expected_npn_protocol },
502     { "ExpectedALPNProtocol", &parse_test_expected_alpn_protocol },
503     { "HandshakeMode", &parse_handshake_mode },
504     { "ResumptionExpected", &parse_test_resumption_expected },
505     { "ApplicationData", &parse_test_app_data_size },
506     { "MaxFragmentSize", &parse_test_max_fragment_size },
507     { "ExpectedTmpKeyType", &parse_expected_tmp_key_type },
508     { "ExpectedServerCertType", &parse_expected_server_cert_type },
509     { "ExpectedClientCertType", &parse_expected_client_cert_type },
510 };
511
512 /* Nested client options. */
513 typedef struct {
514     const char *name;
515     int (*parse)(SSL_TEST_CLIENT_CONF *conf, const char *value);
516 } ssl_test_client_option;
517
518 static const ssl_test_client_option ssl_test_client_options[] = {
519     { "VerifyCallback", &parse_client_verify_callback },
520     { "ServerName", &parse_servername },
521     { "NPNProtocols", &parse_client_npn_protocols },
522     { "ALPNProtocols", &parse_client_alpn_protocols },
523     { "CTValidation", &parse_ct_validation },
524 };
525
526 /* Nested server options. */
527 typedef struct {
528     const char *name;
529     int (*parse)(SSL_TEST_SERVER_CONF *conf, const char *value);
530 } ssl_test_server_option;
531
532 static const ssl_test_server_option ssl_test_server_options[] = {
533     { "ServerNameCallback", &parse_servername_callback },
534     { "NPNProtocols", &parse_server_npn_protocols },
535     { "ALPNProtocols", &parse_server_alpn_protocols },
536     { "BrokenSessionTicket", &parse_server_broken_session_ticket },
537     { "CertStatus", &parse_certstatus },
538 };
539
540 /*
541  * Since these methods are used to create tests, we use TEST_check liberally
542  * for malloc failures and other internal errors.
543  */
544 SSL_TEST_CTX *SSL_TEST_CTX_new()
545 {
546     SSL_TEST_CTX *ret;
547     ret = OPENSSL_zalloc(sizeof(*ret));
548     TEST_check(ret != NULL);
549     ret->app_data_size = default_app_data_size;
550     ret->max_fragment_size = default_max_fragment_size;
551     return ret;
552 }
553
554 static void ssl_test_extra_conf_free_data(SSL_TEST_EXTRA_CONF *conf)
555 {
556     OPENSSL_free(conf->client.npn_protocols);
557     OPENSSL_free(conf->server.npn_protocols);
558     OPENSSL_free(conf->server2.npn_protocols);
559     OPENSSL_free(conf->client.alpn_protocols);
560     OPENSSL_free(conf->server.alpn_protocols);
561     OPENSSL_free(conf->server2.alpn_protocols);
562 }
563
564 static void ssl_test_ctx_free_extra_data(SSL_TEST_CTX *ctx)
565 {
566     ssl_test_extra_conf_free_data(&ctx->extra);
567     ssl_test_extra_conf_free_data(&ctx->resume_extra);
568 }
569
570 void SSL_TEST_CTX_free(SSL_TEST_CTX *ctx)
571 {
572     ssl_test_ctx_free_extra_data(ctx);
573     OPENSSL_free(ctx->expected_npn_protocol);
574     OPENSSL_free(ctx->expected_alpn_protocol);
575     OPENSSL_free(ctx);
576 }
577
578 static int parse_client_options(SSL_TEST_CLIENT_CONF *client, const CONF *conf,
579                                 const char *client_section)
580 {
581     STACK_OF(CONF_VALUE) *sk_conf;
582     int i;
583     size_t j;
584
585     sk_conf = NCONF_get_section(conf, client_section);
586     TEST_check(sk_conf != NULL);
587
588     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
589         int found = 0;
590         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
591         for (j = 0; j < OSSL_NELEM(ssl_test_client_options); j++) {
592             if (strcmp(option->name, ssl_test_client_options[j].name) == 0) {
593                 if (!ssl_test_client_options[j].parse(client, option->value)) {
594                     fprintf(stderr, "Bad value %s for option %s\n",
595                             option->value, option->name);
596                     return 0;
597                 }
598                 found = 1;
599                 break;
600             }
601         }
602         if (!found) {
603             fprintf(stderr, "Unknown test option: %s\n", option->name);
604             return 0;
605         }
606     }
607
608     return 1;
609 }
610
611 static int parse_server_options(SSL_TEST_SERVER_CONF *server, const CONF *conf,
612                                 const char *server_section)
613 {
614     STACK_OF(CONF_VALUE) *sk_conf;
615     int i;
616     size_t j;
617
618     sk_conf = NCONF_get_section(conf, server_section);
619     TEST_check(sk_conf != NULL);
620
621     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
622         int found = 0;
623         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
624         for (j = 0; j < OSSL_NELEM(ssl_test_server_options); j++) {
625             if (strcmp(option->name, ssl_test_server_options[j].name) == 0) {
626                 if (!ssl_test_server_options[j].parse(server, option->value)) {
627                     fprintf(stderr, "Bad value %s for option %s\n",
628                             option->value, option->name);
629                     return 0;
630                 }
631                 found = 1;
632                 break;
633             }
634         }
635         if (!found) {
636             fprintf(stderr, "Unknown test option: %s\n", option->name);
637             return 0;
638         }
639     }
640
641     return 1;
642 }
643
644 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
645 {
646     STACK_OF(CONF_VALUE) *sk_conf;
647     SSL_TEST_CTX *ctx;
648     int i;
649     size_t j;
650
651     sk_conf = NCONF_get_section(conf, test_section);
652     TEST_check(sk_conf != NULL);
653
654     ctx = SSL_TEST_CTX_new();
655     TEST_check(ctx != NULL);
656
657     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
658         int found = 0;
659         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
660
661         /* Subsections */
662         if (strcmp(option->name, "client") == 0) {
663             if (!parse_client_options(&ctx->extra.client, conf,
664                                       option->value))
665                 goto err;
666         } else if (strcmp(option->name, "server") == 0) {
667             if (!parse_server_options(&ctx->extra.server, conf,
668                                       option->value))
669                 goto err;
670         } else if (strcmp(option->name, "server2") == 0) {
671             if (!parse_server_options(&ctx->extra.server2, conf,
672                                       option->value))
673                 goto err;
674         } else if (strcmp(option->name, "resume-client") == 0) {
675             if (!parse_client_options(&ctx->resume_extra.client, conf,
676                                       option->value))
677                 goto err;
678         } else if (strcmp(option->name, "resume-server") == 0) {
679             if (!parse_server_options(&ctx->resume_extra.server, conf,
680                                       option->value))
681                 goto err;
682         } else if (strcmp(option->name, "resume-server2") == 0) {
683             if (!parse_server_options(&ctx->resume_extra.server2, conf,
684                                       option->value))
685                 goto err;
686
687         } else {
688             for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
689                 if (strcmp(option->name, ssl_test_ctx_options[j].name) == 0) {
690                     if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
691                         fprintf(stderr, "Bad value %s for option %s\n",
692                                 option->value, option->name);
693                         goto err;
694                     }
695                     found = 1;
696                     break;
697                 }
698             }
699             if (!found) {
700                 fprintf(stderr, "Unknown test option: %s\n", option->name);
701                 goto err;
702             }
703         }
704     }
705
706     goto done;
707
708  err:
709     SSL_TEST_CTX_free(ctx);
710     ctx = NULL;
711  done:
712     return ctx;
713 }