Let test handshakes stop on certain errors
[openssl.git] / test / ssltestlib.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 "ssltestlib.h"
13
14 static int tls_dump_new(BIO *bi);
15 static int tls_dump_free(BIO *a);
16 static int tls_dump_read(BIO *b, char *out, int outl);
17 static int tls_dump_write(BIO *b, const char *in, int inl);
18 static long tls_dump_ctrl(BIO *b, int cmd, long num, void *ptr);
19 static int tls_dump_gets(BIO *bp, char *buf, int size);
20 static int tls_dump_puts(BIO *bp, const char *str);
21
22 /* Choose a sufficiently large type likely to be unused for this custom BIO */
23 # define BIO_TYPE_TLS_DUMP_FILTER  (0x80 | BIO_TYPE_FILTER)
24
25 # define BIO_TYPE_MEMPACKET_TEST      0x81
26
27 static BIO_METHOD *method_tls_dump = NULL;
28 static BIO_METHOD *method_mempacket_test = NULL;
29
30 /* Note: Not thread safe! */
31 const BIO_METHOD *bio_f_tls_dump_filter(void)
32 {
33     if (method_tls_dump == NULL) {
34         method_tls_dump = BIO_meth_new(BIO_TYPE_TLS_DUMP_FILTER,
35                                         "TLS dump filter");
36         if (   method_tls_dump == NULL
37             || !BIO_meth_set_write(method_tls_dump, tls_dump_write)
38             || !BIO_meth_set_read(method_tls_dump, tls_dump_read)
39             || !BIO_meth_set_puts(method_tls_dump, tls_dump_puts)
40             || !BIO_meth_set_gets(method_tls_dump, tls_dump_gets)
41             || !BIO_meth_set_ctrl(method_tls_dump, tls_dump_ctrl)
42             || !BIO_meth_set_create(method_tls_dump, tls_dump_new)
43             || !BIO_meth_set_destroy(method_tls_dump, tls_dump_free))
44             return NULL;
45     }
46     return method_tls_dump;
47 }
48
49 void bio_f_tls_dump_filter_free(void)
50 {
51     BIO_meth_free(method_tls_dump);
52 }
53
54 static int tls_dump_new(BIO *bio)
55 {
56     BIO_set_init(bio, 1);
57     return 1;
58 }
59
60 static int tls_dump_free(BIO *bio)
61 {
62     BIO_set_init(bio, 0);
63
64     return 1;
65 }
66
67 static void copy_flags(BIO *bio)
68 {
69     int flags;
70     BIO *next = BIO_next(bio);
71
72     flags = BIO_test_flags(next, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_RWS);
73     BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_RWS);
74     BIO_set_flags(bio, flags);
75 }
76
77 #define RECORD_CONTENT_TYPE     0
78 #define RECORD_VERSION_HI       1
79 #define RECORD_VERSION_LO       2
80 #define RECORD_EPOCH_HI         3
81 #define RECORD_EPOCH_LO         4
82 #define RECORD_SEQUENCE_START   5
83 #define RECORD_SEQUENCE_END     10
84 #define RECORD_LEN_HI           11
85 #define RECORD_LEN_LO           12
86
87 #define MSG_TYPE                0
88 #define MSG_LEN_HI              1
89 #define MSG_LEN_MID             2
90 #define MSG_LEN_LO              3
91 #define MSG_SEQ_HI              4
92 #define MSG_SEQ_LO              5
93 #define MSG_FRAG_OFF_HI         6
94 #define MSG_FRAG_OFF_MID        7
95 #define MSG_FRAG_OFF_LO         8
96 #define MSG_FRAG_LEN_HI         9
97 #define MSG_FRAG_LEN_MID        10
98 #define MSG_FRAG_LEN_LO         11
99
100
101 static void dump_data(const char *data, int len)
102 {
103     int rem, i, content, reclen, msglen, fragoff, fraglen, epoch;
104     unsigned char *rec;
105
106     printf("---- START OF PACKET ----\n");
107
108     rem = len;
109     rec = (unsigned char *)data;
110
111     while (rem > 0) {
112         if (rem != len)
113             printf("*\n");
114         printf("*---- START OF RECORD ----\n");
115         if (rem < DTLS1_RT_HEADER_LENGTH) {
116             printf("*---- RECORD TRUNCATED ----\n");
117             break;
118         }
119         content = rec[RECORD_CONTENT_TYPE];
120         printf("** Record Content-type: %d\n", content);
121         printf("** Record Version: %02x%02x\n",
122                rec[RECORD_VERSION_HI], rec[RECORD_VERSION_LO]);
123         epoch = (rec[RECORD_EPOCH_HI] << 8) | rec[RECORD_EPOCH_LO];
124         printf("** Record Epoch: %d\n", epoch);
125         printf("** Record Sequence: ");
126         for (i = RECORD_SEQUENCE_START; i <= RECORD_SEQUENCE_END; i++)
127             printf("%02x", rec[i]);
128         reclen = (rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO];
129         printf("\n** Record Length: %d\n", reclen);
130
131         /* Now look at message */
132         rec += DTLS1_RT_HEADER_LENGTH;
133         rem -= DTLS1_RT_HEADER_LENGTH;
134         if (content == SSL3_RT_HANDSHAKE) {
135             printf("**---- START OF HANDSHAKE MESSAGE FRAGMENT ----\n");
136             if (epoch > 0) {
137                 printf("**---- HANDSHAKE MESSAGE FRAGMENT ENCRYPTED ----\n");
138             } else if (rem < DTLS1_HM_HEADER_LENGTH
139                     || reclen < DTLS1_HM_HEADER_LENGTH) {
140                 printf("**---- HANDSHAKE MESSAGE FRAGMENT TRUNCATED ----\n");
141             } else {
142                 printf("*** Message Type: %d\n", rec[MSG_TYPE]);
143                 msglen = (rec[MSG_LEN_HI] << 16) | (rec[MSG_LEN_MID] << 8)
144                          | rec[MSG_LEN_LO];
145                 printf("*** Message Length: %d\n", msglen);
146                 printf("*** Message sequence: %d\n",
147                        (rec[MSG_SEQ_HI] << 8) | rec[MSG_SEQ_LO]);
148                 fragoff = (rec[MSG_FRAG_OFF_HI] << 16)
149                           | (rec[MSG_FRAG_OFF_MID] << 8)
150                           | rec[MSG_FRAG_OFF_LO];
151                 printf("*** Message Fragment offset: %d\n", fragoff);
152                 fraglen = (rec[MSG_FRAG_LEN_HI] << 16)
153                           | (rec[MSG_FRAG_LEN_MID] << 8)
154                           | rec[MSG_FRAG_LEN_LO];
155                 printf("*** Message Fragment len: %d\n", fraglen);
156                 if (fragoff + fraglen > msglen)
157                     printf("***---- HANDSHAKE MESSAGE FRAGMENT INVALID ----\n");
158                 else if (reclen < fraglen)
159                     printf("**---- HANDSHAKE MESSAGE FRAGMENT TRUNCATED ----\n");
160                 else
161                     printf("**---- END OF HANDSHAKE MESSAGE FRAGMENT ----\n");
162             }
163         }
164         if (rem < reclen) {
165             printf("*---- RECORD TRUNCATED ----\n");
166             rem = 0;
167         } else {
168             rec += reclen;
169             rem -= reclen;
170             printf("*---- END OF RECORD ----\n");
171         }
172     }
173     printf("---- END OF PACKET ----\n\n");
174     fflush(stdout);
175 }
176
177 static int tls_dump_read(BIO *bio, char *out, int outl)
178 {
179     int ret;
180     BIO *next = BIO_next(bio);
181
182     ret = BIO_read(next, out, outl);
183     copy_flags(bio);
184
185     if (ret > 0) {
186         dump_data(out, ret);
187     }
188
189     return ret;
190 }
191
192 static int tls_dump_write(BIO *bio, const char *in, int inl)
193 {
194     int ret;
195     BIO *next = BIO_next(bio);
196
197     ret = BIO_write(next, in, inl);
198     copy_flags(bio);
199
200     return ret;
201 }
202
203 static long tls_dump_ctrl(BIO *bio, int cmd, long num, void *ptr)
204 {
205     long ret;
206     BIO *next = BIO_next(bio);
207
208     if (next == NULL)
209         return 0;
210
211     switch (cmd) {
212     case BIO_CTRL_DUP:
213         ret = 0L;
214         break;
215     default:
216         ret = BIO_ctrl(next, cmd, num, ptr);
217         break;
218     }
219     return ret;
220 }
221
222 static int tls_dump_gets(BIO *bio, char *buf, int size)
223 {
224     /* We don't support this - not needed anyway */
225     return -1;
226 }
227
228 static int tls_dump_puts(BIO *bio, const char *str)
229 {
230     return tls_dump_write(bio, str, strlen(str));
231 }
232
233
234 struct mempacket_st {
235     unsigned char *data;
236     int len;
237     unsigned int num;
238     unsigned int type;
239 };
240
241 static void mempacket_free(MEMPACKET *pkt)
242 {
243     if (pkt->data != NULL)
244         OPENSSL_free(pkt->data);
245     OPENSSL_free(pkt);
246 }
247
248 typedef struct mempacket_test_ctx_st {
249     STACK_OF(MEMPACKET) *pkts;
250     unsigned int epoch;
251     unsigned int currrec;
252     unsigned int currpkt;
253     unsigned int lastpkt;
254     unsigned int noinject;
255 } MEMPACKET_TEST_CTX;
256
257 static int mempacket_test_new(BIO *bi);
258 static int mempacket_test_free(BIO *a);
259 static int mempacket_test_read(BIO *b, char *out, int outl);
260 static int mempacket_test_write(BIO *b, const char *in, int inl);
261 static long mempacket_test_ctrl(BIO *b, int cmd, long num, void *ptr);
262 static int mempacket_test_gets(BIO *bp, char *buf, int size);
263 static int mempacket_test_puts(BIO *bp, const char *str);
264
265 const BIO_METHOD *bio_s_mempacket_test(void)
266 {
267     if (method_mempacket_test == NULL) {
268         method_mempacket_test = BIO_meth_new(BIO_TYPE_MEMPACKET_TEST,
269                                              "Mem Packet Test");
270         if (   method_mempacket_test == NULL
271             || !BIO_meth_set_write(method_mempacket_test, mempacket_test_write)
272             || !BIO_meth_set_read(method_mempacket_test, mempacket_test_read)
273             || !BIO_meth_set_puts(method_mempacket_test, mempacket_test_puts)
274             || !BIO_meth_set_gets(method_mempacket_test, mempacket_test_gets)
275             || !BIO_meth_set_ctrl(method_mempacket_test, mempacket_test_ctrl)
276             || !BIO_meth_set_create(method_mempacket_test, mempacket_test_new)
277             || !BIO_meth_set_destroy(method_mempacket_test, mempacket_test_free))
278             return NULL;
279     }
280     return method_mempacket_test;
281 }
282
283 void bio_s_mempacket_test_free(void)
284 {
285     BIO_meth_free(method_mempacket_test);
286 }
287
288 static int mempacket_test_new(BIO *bio)
289 {
290     MEMPACKET_TEST_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
291     if (ctx == NULL)
292         return 0;
293     ctx->pkts = sk_MEMPACKET_new_null();
294     if (ctx->pkts == NULL) {
295         OPENSSL_free(ctx);
296         return 0;
297     }
298     BIO_set_init(bio, 1);
299     BIO_set_data(bio, ctx);
300     return 1;
301 }
302
303 static int mempacket_test_free(BIO *bio)
304 {
305     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
306
307     sk_MEMPACKET_pop_free(ctx->pkts, mempacket_free);
308     OPENSSL_free(ctx);
309     BIO_set_data(bio, NULL);
310     BIO_set_init(bio, 0);
311
312     return 1;
313 }
314
315 /* Record Header values */
316 #define EPOCH_HI        4
317 #define EPOCH_LO        5
318 #define RECORD_SEQUENCE 10
319 #define RECORD_LEN_HI   11
320 #define RECORD_LEN_LO   12
321
322 #define STANDARD_PACKET                 0
323
324 static int mempacket_test_read(BIO *bio, char *out, int outl)
325 {
326     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
327     MEMPACKET *thispkt;
328     unsigned char *rec;
329     int rem;
330     unsigned int seq, offset, len, epoch;
331
332     BIO_clear_retry_flags(bio);
333
334     thispkt = sk_MEMPACKET_value(ctx->pkts, 0);
335     if (thispkt == NULL || thispkt->num != ctx->currpkt) {
336         /* Probably run out of data */
337         BIO_set_retry_read(bio);
338         return -1;
339     }
340     (void)sk_MEMPACKET_shift(ctx->pkts);
341     ctx->currpkt++;
342
343     if (outl > thispkt->len)
344         outl = thispkt->len;
345
346     if (thispkt->type != INJECT_PACKET_IGNORE_REC_SEQ) {
347         /*
348          * Overwrite the record sequence number. We strictly number them in
349          * the order received. Since we are actually a reliable transport
350          * we know that there won't be any re-ordering. We overwrite to deal
351          * with any packets that have been injected
352          */
353         rem = thispkt->len;
354         rec = thispkt->data;
355         while (rem > 0) {
356             if (rem < DTLS1_RT_HEADER_LENGTH) {
357                 return -1;
358             }
359             epoch = (rec[EPOCH_HI] << 8) | rec[EPOCH_LO];
360             if (epoch != ctx->epoch) {
361                 ctx->epoch = epoch;
362                 ctx->currrec = 0;
363             }
364             seq = ctx->currrec;
365             offset = 0;
366             do {
367                 rec[RECORD_SEQUENCE - offset] = seq & 0xFF;
368                 seq >>= 8;
369                 offset++;
370             } while (seq > 0);
371             ctx->currrec++;
372
373             len = ((rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO])
374                   + DTLS1_RT_HEADER_LENGTH;
375
376             rec += len;
377             rem -= len;
378         }
379     }
380
381     memcpy(out, thispkt->data, outl);
382
383     mempacket_free(thispkt);
384
385     return outl;
386 }
387
388 int mempacket_test_inject(BIO *bio, const char *in, int inl, int pktnum,
389                           int type)
390 {
391     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
392     MEMPACKET *thispkt, *looppkt, *nextpkt;
393     int i;
394
395     if (ctx == NULL)
396         return -1;
397
398     /* We only allow injection before we've started writing any data */
399     if (pktnum >= 0) {
400         if (ctx->noinject)
401             return -1;
402     } else {
403         ctx->noinject = 1;
404     }
405
406     thispkt = OPENSSL_malloc(sizeof(MEMPACKET));
407     if (thispkt == NULL)
408         return -1;
409
410     thispkt->data = OPENSSL_malloc(inl);
411     if (thispkt->data == NULL) {
412         mempacket_free(thispkt);
413         return -1;
414     }
415
416     memcpy(thispkt->data, in, inl);
417     thispkt->len = inl;
418     thispkt->num = (pktnum >= 0) ? (unsigned int)pktnum : ctx->lastpkt;
419     thispkt->type = type;
420
421     for(i = 0; (looppkt = sk_MEMPACKET_value(ctx->pkts, i)) != NULL; i++) {
422         /* Check if we found the right place to insert this packet */
423         if (looppkt->num > thispkt->num) {
424             if (sk_MEMPACKET_insert(ctx->pkts, thispkt, i) == 0) {
425                 mempacket_free(thispkt);
426                 return -1;
427             }
428             /* If we're doing up front injection then we're done */
429             if (pktnum >= 0)
430                 return inl;
431             /*
432              * We need to do some accounting on lastpkt. We increment it first,
433              * but it might now equal the value of injected packets, so we need
434              * to skip over those
435              */
436             ctx->lastpkt++;
437             do {
438                 i++;
439                 nextpkt = sk_MEMPACKET_value(ctx->pkts, i);
440                 if (nextpkt != NULL && nextpkt->num == ctx->lastpkt)
441                     ctx->lastpkt++;
442                 else
443                     return inl;
444             } while(1);
445         } else if (looppkt->num == thispkt->num) {
446             if (!ctx->noinject) {
447                 /* We injected two packets with the same packet number! */
448                 return -1;
449             }
450             ctx->lastpkt++;
451             thispkt->num++;
452         }
453     }
454     /*
455      * We didn't find any packets with a packet number equal to or greater than
456      * this one, so we just add it onto the end
457      */
458     if (!sk_MEMPACKET_push(ctx->pkts, thispkt)) {
459         mempacket_free(thispkt);
460         return -1;
461     }
462
463     if (pktnum < 0)
464         ctx->lastpkt++;
465
466     return inl;
467 }
468
469 static int mempacket_test_write(BIO *bio, const char *in, int inl)
470 {
471     return mempacket_test_inject(bio, in, inl, -1, STANDARD_PACKET);
472 }
473
474 static long mempacket_test_ctrl(BIO *bio, int cmd, long num, void *ptr)
475 {
476     long ret = 1;
477     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
478     MEMPACKET *thispkt;
479
480     switch (cmd) {
481     case BIO_CTRL_EOF:
482         ret = (long)(sk_MEMPACKET_num(ctx->pkts) == 0);
483         break;
484     case BIO_CTRL_GET_CLOSE:
485         ret = BIO_get_shutdown(bio);
486         break;
487     case BIO_CTRL_SET_CLOSE:
488         BIO_set_shutdown(bio, (int)num);
489         break;
490     case BIO_CTRL_WPENDING:
491         ret = 0L;
492         break;
493     case BIO_CTRL_PENDING:
494         thispkt = sk_MEMPACKET_value(ctx->pkts, 0);
495         if (thispkt == NULL)
496             ret = 0;
497         else
498             ret = thispkt->len;
499         break;
500     case BIO_CTRL_FLUSH:
501         ret = 1;
502         break;
503     case BIO_CTRL_RESET:
504     case BIO_CTRL_DUP:
505     case BIO_CTRL_PUSH:
506     case BIO_CTRL_POP:
507     default:
508         ret = 0;
509         break;
510     }
511     return ret;
512 }
513
514 static int mempacket_test_gets(BIO *bio, char *buf, int size)
515 {
516     /* We don't support this - not needed anyway */
517     return -1;
518 }
519
520 static int mempacket_test_puts(BIO *bio, const char *str)
521 {
522     return mempacket_test_write(bio, str, strlen(str));
523 }
524
525 int create_ssl_ctx_pair(const SSL_METHOD *sm, const SSL_METHOD *cm,
526                         SSL_CTX **sctx, SSL_CTX **cctx, char *certfile,
527                         char *privkeyfile)
528 {
529     SSL_CTX *serverctx = NULL;
530     SSL_CTX *clientctx = NULL;
531
532     serverctx = SSL_CTX_new(sm);
533     clientctx = SSL_CTX_new(cm);
534     if (serverctx == NULL || clientctx == NULL) {
535         printf("Failed to create SSL_CTX\n");
536         goto err;
537     }
538
539     if (SSL_CTX_use_certificate_file(serverctx, certfile,
540                                      SSL_FILETYPE_PEM) <= 0) {
541         printf("Failed to load server certificate\n");
542         goto err;
543     }
544     if (SSL_CTX_use_PrivateKey_file(serverctx, privkeyfile,
545                                     SSL_FILETYPE_PEM) <= 0) {
546         printf("Failed to load server private key\n");
547     }
548     if (SSL_CTX_check_private_key(serverctx) <= 0) {
549         printf("Failed to check private key\n");
550         goto err;
551     }
552
553 #ifndef OPENSSL_NO_DH
554     SSL_CTX_set_dh_auto(serverctx, 1);
555 #endif
556
557     *sctx = serverctx;
558     *cctx = clientctx;
559
560     return 1;
561  err:
562     SSL_CTX_free(serverctx);
563     SSL_CTX_free(clientctx);
564     return 0;
565 }
566
567 #define MAXLOOPS    1000000
568
569 /*
570  * NOTE: Transfers control of the BIOs - this function will free them on error
571  */
572 int create_ssl_objects(SSL_CTX *serverctx, SSL_CTX *clientctx, SSL **sssl,
573                           SSL **cssl, BIO *s_to_c_fbio, BIO *c_to_s_fbio)
574 {
575     SSL *serverssl, *clientssl;
576     BIO *s_to_c_bio = NULL, *c_to_s_bio = NULL;
577
578     if (*sssl == NULL)
579         serverssl = SSL_new(serverctx);
580     else
581         serverssl = *sssl;
582     if (*cssl == NULL)
583         clientssl = SSL_new(clientctx);
584     else
585         clientssl = *cssl;
586
587     if (serverssl == NULL || clientssl == NULL) {
588         printf("Failed to create SSL object\n");
589         goto error;
590     }
591
592     if (SSL_is_dtls(clientssl)) {
593         s_to_c_bio = BIO_new(bio_s_mempacket_test());
594         c_to_s_bio = BIO_new(bio_s_mempacket_test());
595     } else {
596         s_to_c_bio = BIO_new(BIO_s_mem());
597         c_to_s_bio = BIO_new(BIO_s_mem());
598     }
599     if (s_to_c_bio == NULL || c_to_s_bio == NULL) {
600         printf("Failed to create mem BIOs\n");
601         goto error;
602     }
603
604     if (s_to_c_fbio != NULL)
605         s_to_c_bio = BIO_push(s_to_c_fbio, s_to_c_bio);
606     if (c_to_s_fbio != NULL)
607         c_to_s_bio = BIO_push(c_to_s_fbio, c_to_s_bio);
608     if (s_to_c_bio == NULL || c_to_s_bio == NULL) {
609         printf("Failed to create chained BIOs\n");
610         goto error;
611     }
612
613     /* Set Non-blocking IO behaviour */
614     BIO_set_mem_eof_return(s_to_c_bio, -1);
615     BIO_set_mem_eof_return(c_to_s_bio, -1);
616
617     /* Up ref these as we are passing them to two SSL objects */
618     BIO_up_ref(s_to_c_bio);
619     BIO_up_ref(c_to_s_bio);
620
621     SSL_set_bio(serverssl, c_to_s_bio, s_to_c_bio);
622     SSL_set_bio(clientssl, s_to_c_bio, c_to_s_bio);
623
624     /* BIOs will now be freed when SSL objects are freed */
625     s_to_c_bio = c_to_s_bio = NULL;
626     s_to_c_fbio = c_to_s_fbio = NULL;
627
628     *sssl = serverssl;
629     *cssl = clientssl;
630
631     return 1;
632
633  error:
634     SSL_free(serverssl);
635     SSL_free(clientssl);
636     BIO_free(s_to_c_bio);
637     BIO_free(c_to_s_bio);
638     BIO_free(s_to_c_fbio);
639     BIO_free(c_to_s_fbio);
640
641     return 0;
642 }
643
644 int create_ssl_connection(SSL *serverssl, SSL *clientssl, int want)
645 {
646     int retc = -1, rets = -1, err, abortctr = 0;
647     int clienterr = 0, servererr = 0;
648     unsigned char buf;
649     size_t readbytes;
650
651     do {
652         err = SSL_ERROR_WANT_WRITE;
653         while (!clienterr && retc <= 0 && err == SSL_ERROR_WANT_WRITE) {
654             retc = SSL_connect(clientssl);
655             if (retc <= 0)
656                 err = SSL_get_error(clientssl, retc);
657         }
658
659         if (!clienterr && retc <= 0 && err != SSL_ERROR_WANT_READ) {
660             printf("SSL_connect() failed %d, %d\n", retc, err);
661             clienterr = 1;
662         }
663         if (want != SSL_ERROR_NONE && err == want)
664             return 0;
665
666         err = SSL_ERROR_WANT_WRITE;
667         while (!servererr && rets <= 0 && err == SSL_ERROR_WANT_WRITE) {
668             rets = SSL_accept(serverssl);
669             if (rets <= 0)
670                 err = SSL_get_error(serverssl, rets);
671         }
672
673         if (!servererr && rets <= 0 && err != SSL_ERROR_WANT_READ) {
674             printf("SSL_accept() failed %d, %d\n", rets, err);
675             servererr = 1;
676         }
677         if (want != SSL_ERROR_NONE && err == want)
678             return 0;
679         if (clienterr && servererr)
680             return 0;
681         if (++abortctr == MAXLOOPS) {
682             printf("No progress made\n");
683             return 0;
684         }
685     } while (retc <=0 || rets <= 0);
686
687     /*
688      * We attempt to read some data on the client side which we expect to fail.
689      * This will ensure we have received the NewSessionTicket in TLSv1.3 where
690      * appropriate.
691      */
692     if (SSL_read_ex(clientssl, &buf, sizeof(buf), &readbytes) > 0) {
693         if (readbytes != 0) {
694             printf("Unexpected success reading data %"OSSLzu"\n", readbytes);
695             return 0;
696         }
697     } else if (SSL_get_error(clientssl, 0) != SSL_ERROR_WANT_READ) {
698         printf("SSL_read_ex() failed\n");
699         return 0;
700     }
701
702     return 1;
703 }