Coverage Report

Created: 2024-11-21 07:03

/src/openssl/crypto/bio/bss_conn.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1995-2024 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 <stdio.h>
11
#include <errno.h>
12
13
#include "bio_local.h"
14
#include "internal/bio_tfo.h"
15
#include "internal/ktls.h"
16
17
#ifndef OPENSSL_NO_SOCK
18
19
typedef struct bio_connect_st {
20
    int state;
21
    int connect_family;
22
    int connect_sock_type;
23
    char *param_hostname;
24
    char *param_service;
25
    int connect_mode;
26
# ifndef OPENSSL_NO_KTLS
27
    unsigned char record_type;
28
# endif
29
    int tfo_first;
30
31
    BIO_ADDRINFO *addr_first;
32
    const BIO_ADDRINFO *addr_iter;
33
    /*
34
     * int socket; this will be kept in bio->num so that it is compatible
35
     * with the bss_sock bio
36
     */
37
    /*
38
     * called when the connection is initially made callback(BIO,state,ret);
39
     * The callback should return 'ret'.  state is for compatibility with the
40
     * ssl info_callback
41
     */
42
    BIO_info_cb *info_callback;
43
    /*
44
     * Used when connect_sock_type is SOCK_DGRAM. Owned by us; we forward
45
     * read/write(mmsg) calls to this if present.
46
     */
47
    BIO *dgram_bio;
48
} BIO_CONNECT;
49
50
static int conn_write(BIO *h, const char *buf, int num);
51
static int conn_read(BIO *h, char *buf, int size);
52
static int conn_puts(BIO *h, const char *str);
53
static int conn_gets(BIO *h, char *buf, int size);
54
static long conn_ctrl(BIO *h, int cmd, long arg1, void *arg2);
55
static int conn_new(BIO *h);
56
static int conn_free(BIO *data);
57
static long conn_callback_ctrl(BIO *h, int cmd, BIO_info_cb *);
58
static int conn_sendmmsg(BIO *h, BIO_MSG *m, size_t s, size_t n,
59
                         uint64_t f, size_t *mp);
60
static int conn_recvmmsg(BIO *h, BIO_MSG *m, size_t s, size_t n,
61
                         uint64_t f, size_t *mp);
62
63
static int conn_state(BIO *b, BIO_CONNECT *c);
64
static void conn_close_socket(BIO *data);
65
static BIO_CONNECT *BIO_CONNECT_new(void);
66
static void BIO_CONNECT_free(BIO_CONNECT *a);
67
68
0
#define BIO_CONN_S_BEFORE                1
69
0
#define BIO_CONN_S_GET_ADDR              2
70
0
#define BIO_CONN_S_CREATE_SOCKET         3
71
0
#define BIO_CONN_S_CONNECT               4
72
0
#define BIO_CONN_S_OK                    5
73
0
#define BIO_CONN_S_BLOCKED_CONNECT       6
74
0
#define BIO_CONN_S_CONNECT_ERROR         7
75
76
static const BIO_METHOD methods_connectp = {
77
    BIO_TYPE_CONNECT,
78
    "socket connect",
79
    bwrite_conv,
80
    conn_write,
81
    bread_conv,
82
    conn_read,
83
    conn_puts,
84
    conn_gets,
85
    conn_ctrl,
86
    conn_new,
87
    conn_free,
88
    conn_callback_ctrl,
89
    conn_sendmmsg,
90
    conn_recvmmsg,
91
};
92
93
static int conn_create_dgram_bio(BIO *b, BIO_CONNECT *c)
94
0
{
95
0
    if (c->connect_sock_type != SOCK_DGRAM)
96
0
        return 1;
97
98
0
#ifndef OPENSSL_NO_DGRAM
99
0
    c->dgram_bio = BIO_new_dgram(b->num, 0);
100
0
    if (c->dgram_bio == NULL)
101
0
        goto err;
102
103
0
    return 1;
104
105
0
err:
106
0
#endif
107
0
    c->state = BIO_CONN_S_CONNECT_ERROR;
108
0
    return 0;
109
0
}
110
111
static int conn_state(BIO *b, BIO_CONNECT *c)
112
0
{
113
0
    int ret = -1, i, opts;
114
0
    BIO_info_cb *cb = NULL;
115
116
0
    if (c->info_callback != NULL)
117
0
        cb = c->info_callback;
118
119
0
    for (;;) {
120
0
        switch (c->state) {
121
0
        case BIO_CONN_S_BEFORE:
122
0
            if (c->param_hostname == NULL && c->param_service == NULL) {
123
0
                ERR_raise_data(ERR_LIB_BIO,
124
0
                               BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED,
125
0
                               "hostname=%s service=%s",
126
0
                               c->param_hostname, c->param_service);
127
0
                goto exit_loop;
128
0
            }
129
0
            c->state = BIO_CONN_S_GET_ADDR;
130
0
            break;
131
132
0
        case BIO_CONN_S_GET_ADDR:
133
0
            {
134
0
                int family = AF_UNSPEC;
135
0
                switch (c->connect_family) {
136
0
                case BIO_FAMILY_IPV6:
137
0
                    if (1) { /* This is a trick we use to avoid bit rot.
138
                              * at least the "else" part will always be
139
                              * compiled.
140
                              */
141
0
#if OPENSSL_USE_IPV6
142
0
                        family = AF_INET6;
143
0
                    } else {
144
0
#endif
145
0
                        ERR_raise(ERR_LIB_BIO, BIO_R_UNAVAILABLE_IP_FAMILY);
146
0
                        goto exit_loop;
147
0
                    }
148
0
                    break;
149
0
                case BIO_FAMILY_IPV4:
150
0
                    family = AF_INET;
151
0
                    break;
152
0
                case BIO_FAMILY_IPANY:
153
0
                    family = AF_UNSPEC;
154
0
                    break;
155
0
                default:
156
0
                    ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_IP_FAMILY);
157
0
                    goto exit_loop;
158
0
                }
159
0
                if (BIO_lookup(c->param_hostname, c->param_service,
160
0
                               BIO_LOOKUP_CLIENT,
161
0
                               family, c->connect_sock_type,
162
0
                               &c->addr_first) == 0)
163
0
                    goto exit_loop;
164
0
            }
165
0
            if (c->addr_first == NULL) {
166
0
                ERR_raise(ERR_LIB_BIO, BIO_R_LOOKUP_RETURNED_NOTHING);
167
0
                goto exit_loop;
168
0
            }
169
0
            c->addr_iter = c->addr_first;
170
0
            c->state = BIO_CONN_S_CREATE_SOCKET;
171
0
            break;
172
173
0
        case BIO_CONN_S_CREATE_SOCKET:
174
0
            ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
175
0
                             BIO_ADDRINFO_socktype(c->addr_iter),
176
0
                             BIO_ADDRINFO_protocol(c->addr_iter), 0);
177
0
            if (ret == (int)INVALID_SOCKET) {
178
0
                ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
179
0
                               "calling socket(%s, %s)",
180
0
                               c->param_hostname, c->param_service);
181
0
                ERR_raise(ERR_LIB_BIO, BIO_R_UNABLE_TO_CREATE_SOCKET);
182
0
                goto exit_loop;
183
0
            }
184
0
            b->num = ret;
185
0
            c->state = BIO_CONN_S_CONNECT;
186
0
            break;
187
188
0
        case BIO_CONN_S_CONNECT:
189
0
            BIO_clear_retry_flags(b);
190
0
            ERR_set_mark();
191
192
0
            opts = c->connect_mode;
193
0
            if (BIO_ADDRINFO_socktype(c->addr_iter) == SOCK_STREAM)
194
0
                opts |= BIO_SOCK_KEEPALIVE;
195
196
0
            ret = BIO_connect(b->num, BIO_ADDRINFO_address(c->addr_iter), opts);
197
0
            b->retry_reason = 0;
198
0
            if (ret == 0) {
199
0
                if (BIO_sock_should_retry(ret)) {
200
0
                    BIO_set_retry_special(b);
201
0
                    c->state = BIO_CONN_S_BLOCKED_CONNECT;
202
0
                    b->retry_reason = BIO_RR_CONNECT;
203
0
                    ERR_pop_to_mark();
204
0
                } else if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter))
205
0
                           != NULL) {
206
                    /*
207
                     * if there are more addresses to try, do that first
208
                     */
209
0
                    BIO_closesocket(b->num);
210
0
                    c->state = BIO_CONN_S_CREATE_SOCKET;
211
0
                    ERR_pop_to_mark();
212
0
                    break;
213
0
                } else {
214
0
                    ERR_clear_last_mark();
215
0
                    ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
216
0
                                   "calling connect(%s, %s)",
217
0
                                    c->param_hostname, c->param_service);
218
0
                    c->state = BIO_CONN_S_CONNECT_ERROR;
219
0
                    break;
220
0
                }
221
0
                goto exit_loop;
222
0
            } else {
223
0
                ERR_clear_last_mark();
224
0
                if (!conn_create_dgram_bio(b, c))
225
0
                    break;
226
0
                c->state = BIO_CONN_S_OK;
227
0
            }
228
0
            break;
229
230
0
        case BIO_CONN_S_BLOCKED_CONNECT:
231
            /* wait for socket being writable, before querying BIO_sock_error */
232
0
            if (BIO_socket_wait(b->num, 0, time(NULL)) == 0)
233
0
                break;
234
0
            i = BIO_sock_error(b->num);
235
0
            if (i != 0) {
236
0
                BIO_clear_retry_flags(b);
237
0
                if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter)) != NULL) {
238
                    /*
239
                     * if there are more addresses to try, do that first
240
                     */
241
0
                    BIO_closesocket(b->num);
242
0
                    c->state = BIO_CONN_S_CREATE_SOCKET;
243
0
                    break;
244
0
                }
245
0
                ERR_raise_data(ERR_LIB_SYS, i,
246
0
                               "calling connect(%s, %s)",
247
0
                                c->param_hostname, c->param_service);
248
0
                ERR_raise(ERR_LIB_BIO, BIO_R_NBIO_CONNECT_ERROR);
249
0
                ret = 0;
250
0
                goto exit_loop;
251
0
            } else {
252
0
                if (!conn_create_dgram_bio(b, c))
253
0
                    break;
254
0
                c->state = BIO_CONN_S_OK;
255
# ifndef OPENSSL_NO_KTLS
256
                /*
257
                 * The new socket is created successfully regardless of ktls_enable.
258
                 * ktls_enable doesn't change any functionality of the socket, except
259
                 * changing the setsockopt to enable the processing of ktls_start.
260
                 * Thus, it is not a problem to call it for non-TLS sockets.
261
                 */
262
                ktls_enable(b->num);
263
# endif
264
0
            }
265
0
            break;
266
267
0
        case BIO_CONN_S_CONNECT_ERROR:
268
0
            ERR_raise(ERR_LIB_BIO, BIO_R_CONNECT_ERROR);
269
0
            ret = 0;
270
0
            goto exit_loop;
271
272
0
        case BIO_CONN_S_OK:
273
0
            ret = 1;
274
0
            goto exit_loop;
275
0
        default:
276
            /* abort(); */
277
0
            goto exit_loop;
278
0
        }
279
280
0
        if (cb != NULL) {
281
0
            if ((ret = cb((BIO *)b, c->state, ret)) == 0)
282
0
                goto end;
283
0
        }
284
0
    }
285
286
    /* Loop does not exit */
287
0
 exit_loop:
288
0
    if (cb != NULL)
289
0
        ret = cb((BIO *)b, c->state, ret);
290
0
 end:
291
0
    return ret;
292
0
}
293
294
static BIO_CONNECT *BIO_CONNECT_new(void)
295
0
{
296
0
    BIO_CONNECT *ret;
297
298
0
    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
299
0
        return NULL;
300
0
    ret->state = BIO_CONN_S_BEFORE;
301
0
    ret->connect_family = BIO_FAMILY_IPANY;
302
0
    ret->connect_sock_type = SOCK_STREAM;
303
0
    return ret;
304
0
}
305
306
static void BIO_CONNECT_free(BIO_CONNECT *a)
307
0
{
308
0
    if (a == NULL)
309
0
        return;
310
0
    OPENSSL_free(a->param_hostname);
311
0
    OPENSSL_free(a->param_service);
312
0
    BIO_ADDRINFO_free(a->addr_first);
313
0
    OPENSSL_free(a);
314
0
}
315
316
const BIO_METHOD *BIO_s_connect(void)
317
0
{
318
0
    return &methods_connectp;
319
0
}
320
321
static int conn_new(BIO *bi)
322
0
{
323
0
    bi->init = 0;
324
0
    bi->num = (int)INVALID_SOCKET;
325
0
    bi->flags = 0;
326
0
    if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL)
327
0
        return 0;
328
0
    else
329
0
        return 1;
330
0
}
331
332
static void conn_close_socket(BIO *bio)
333
0
{
334
0
    BIO_CONNECT *c;
335
336
0
    c = (BIO_CONNECT *)bio->ptr;
337
0
    if (bio->num != (int)INVALID_SOCKET) {
338
        /* Only do a shutdown if things were established */
339
0
        if (c->state == BIO_CONN_S_OK)
340
0
            shutdown(bio->num, 2);
341
0
        BIO_closesocket(bio->num);
342
0
        bio->num = (int)INVALID_SOCKET;
343
0
    }
344
0
}
345
346
static int conn_free(BIO *a)
347
0
{
348
0
    BIO_CONNECT *data;
349
350
0
    if (a == NULL)
351
0
        return 0;
352
0
    data = (BIO_CONNECT *)a->ptr;
353
354
0
    BIO_free(data->dgram_bio);
355
356
0
    if (a->shutdown) {
357
0
        conn_close_socket(a);
358
0
        BIO_CONNECT_free(data);
359
0
        a->ptr = NULL;
360
0
        a->flags = 0;
361
0
        a->init = 0;
362
0
    }
363
0
    return 1;
364
0
}
365
366
static int conn_read(BIO *b, char *out, int outl)
367
0
{
368
0
    int ret = 0;
369
0
    BIO_CONNECT *data;
370
371
0
    data = (BIO_CONNECT *)b->ptr;
372
0
    if (data->state != BIO_CONN_S_OK) {
373
0
        ret = conn_state(b, data);
374
0
        if (ret <= 0)
375
0
            return ret;
376
0
    }
377
378
0
    if (data->dgram_bio != NULL) {
379
0
        BIO_clear_retry_flags(b);
380
0
        ret = BIO_read(data->dgram_bio, out, outl);
381
0
        BIO_set_flags(b, BIO_get_retry_flags(data->dgram_bio));
382
0
        return ret;
383
0
    }
384
385
0
    if (out != NULL) {
386
0
        clear_socket_error();
387
# ifndef OPENSSL_NO_KTLS
388
        if (BIO_get_ktls_recv(b))
389
            ret = ktls_read_record(b->num, out, outl);
390
        else
391
# endif
392
0
            ret = readsocket(b->num, out, outl);
393
0
        BIO_clear_retry_flags(b);
394
0
        if (ret <= 0) {
395
0
            if (BIO_sock_should_retry(ret))
396
0
                BIO_set_retry_read(b);
397
0
            else if (ret == 0)
398
0
                b->flags |= BIO_FLAGS_IN_EOF;
399
0
        }
400
0
    }
401
0
    return ret;
402
0
}
403
404
static int conn_write(BIO *b, const char *in, int inl)
405
0
{
406
0
    int ret;
407
0
    BIO_CONNECT *data;
408
409
0
    data = (BIO_CONNECT *)b->ptr;
410
0
    if (data->state != BIO_CONN_S_OK) {
411
0
        ret = conn_state(b, data);
412
0
        if (ret <= 0)
413
0
            return ret;
414
0
    }
415
416
0
    if (data->dgram_bio != NULL) {
417
0
        BIO_clear_retry_flags(b);
418
0
        ret = BIO_write(data->dgram_bio, in, inl);
419
0
        BIO_set_flags(b, BIO_get_retry_flags(data->dgram_bio));
420
0
        return ret;
421
0
    }
422
423
0
    clear_socket_error();
424
# ifndef OPENSSL_NO_KTLS
425
    if (BIO_should_ktls_ctrl_msg_flag(b)) {
426
        ret = ktls_send_ctrl_message(b->num, data->record_type, in, inl);
427
        if (ret >= 0) {
428
            ret = inl;
429
            BIO_clear_ktls_ctrl_msg_flag(b);
430
        }
431
    } else
432
# endif
433
# if defined(OSSL_TFO_SENDTO)
434
    if (data->tfo_first) {
435
        int peerlen = BIO_ADDRINFO_sockaddr_size(data->addr_iter);
436
437
        ret = sendto(b->num, in, inl, OSSL_TFO_SENDTO,
438
                     BIO_ADDRINFO_sockaddr(data->addr_iter), peerlen);
439
        data->tfo_first = 0;
440
    } else
441
# endif
442
0
        ret = writesocket(b->num, in, inl);
443
0
    BIO_clear_retry_flags(b);
444
0
    if (ret <= 0) {
445
0
        if (BIO_sock_should_retry(ret))
446
0
            BIO_set_retry_write(b);
447
0
    }
448
0
    return ret;
449
0
}
450
451
static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
452
0
{
453
0
    BIO *dbio;
454
0
    int *ip;
455
0
    const char **pptr = NULL;
456
0
    long ret = 1;
457
0
    BIO_CONNECT *data;
458
0
    const BIO_ADDR *dg_addr;
459
# ifndef OPENSSL_NO_KTLS
460
    ktls_crypto_info_t *crypto_info;
461
# endif
462
463
0
    data = (BIO_CONNECT *)b->ptr;
464
465
0
    switch (cmd) {
466
0
    case BIO_CTRL_RESET:
467
0
        ret = 0;
468
0
        data->state = BIO_CONN_S_BEFORE;
469
0
        conn_close_socket(b);
470
0
        BIO_ADDRINFO_free(data->addr_first);
471
0
        data->addr_first = NULL;
472
0
        b->flags = 0;
473
0
        break;
474
0
    case BIO_C_DO_STATE_MACHINE:
475
        /* use this one to start the connection */
476
0
        if (data->state != BIO_CONN_S_OK)
477
0
            ret = (long)conn_state(b, data);
478
0
        else
479
0
            ret = 1;
480
0
        break;
481
0
    case BIO_C_GET_CONNECT:
482
0
        if (ptr != NULL) {
483
0
            pptr = (const char **)ptr;
484
0
            if (num == 0) {
485
0
                *pptr = data->param_hostname;
486
0
            } else if (num == 1) {
487
0
                *pptr = data->param_service;
488
0
            } else if (num == 2) {
489
0
                *pptr = (const char *)BIO_ADDRINFO_address(data->addr_iter);
490
0
            } else if (num == 3) {
491
0
                switch (BIO_ADDRINFO_family(data->addr_iter)) {
492
0
# if OPENSSL_USE_IPV6
493
0
                case AF_INET6:
494
0
                    ret = BIO_FAMILY_IPV6;
495
0
                    break;
496
0
# endif
497
0
                case AF_INET:
498
0
                    ret = BIO_FAMILY_IPV4;
499
0
                    break;
500
0
                case 0:
501
0
                    ret = data->connect_family;
502
0
                    break;
503
0
                default:
504
0
                    ret = -1;
505
0
                    break;
506
0
                }
507
0
            } else if (num == 4) {
508
0
                ret = data->connect_mode;
509
0
            } else {
510
0
                ret = 0;
511
0
            }
512
0
        } else {
513
0
            ret = 0;
514
0
        }
515
0
        break;
516
0
    case BIO_C_SET_CONNECT:
517
0
        if (ptr != NULL) {
518
0
            b->init = 1;
519
0
            if (num == 0) { /* BIO_set_conn_hostname */
520
0
                char *hold_service = data->param_service;
521
                /* We affect the hostname regardless.  However, the input
522
                 * string might contain a host:service spec, so we must
523
                 * parse it, which might or might not affect the service
524
                 */
525
526
0
                OPENSSL_free(data->param_hostname);
527
0
                data->param_hostname = NULL;
528
0
                ret = BIO_parse_hostserv(ptr,
529
0
                                         &data->param_hostname,
530
0
                                         &data->param_service,
531
0
                                         BIO_PARSE_PRIO_HOST);
532
0
                if (hold_service != data->param_service)
533
0
                    OPENSSL_free(hold_service);
534
0
            } else if (num == 1) { /* BIO_set_conn_port */
535
0
                OPENSSL_free(data->param_service);
536
0
                if ((data->param_service = OPENSSL_strdup(ptr)) == NULL)
537
0
                    ret = 0;
538
0
            } else if (num == 2) { /* BIO_set_conn_address */
539
0
                const BIO_ADDR *addr = (const BIO_ADDR *)ptr;
540
0
                char *host = BIO_ADDR_hostname_string(addr, 1);
541
0
                char *service = BIO_ADDR_service_string(addr, 1);
542
543
0
                ret = host != NULL && service != NULL;
544
0
                if (ret) {
545
0
                    OPENSSL_free(data->param_hostname);
546
0
                    data->param_hostname = host;
547
0
                    OPENSSL_free(data->param_service);
548
0
                    data->param_service = service;
549
0
                    BIO_ADDRINFO_free(data->addr_first);
550
0
                    data->addr_first = NULL;
551
0
                    data->addr_iter = NULL;
552
0
                } else {
553
0
                    OPENSSL_free(host);
554
0
                    OPENSSL_free(service);
555
0
                }
556
0
            } else if (num == 3) { /* BIO_set_conn_ip_family */
557
0
                data->connect_family = *(int *)ptr;
558
0
            } else {
559
0
                ret = 0;
560
0
            }
561
0
        }
562
0
        break;
563
0
    case BIO_C_SET_SOCK_TYPE:
564
0
        if ((num != SOCK_STREAM && num != SOCK_DGRAM)
565
0
            || data->state >= BIO_CONN_S_GET_ADDR) {
566
0
            ret = 0;
567
0
            break;
568
0
        }
569
570
0
        data->connect_sock_type = (int)num;
571
0
        ret = 1;
572
0
        break;
573
0
    case BIO_C_GET_SOCK_TYPE:
574
0
        ret = data->connect_sock_type;
575
0
        break;
576
0
    case BIO_C_GET_DGRAM_BIO:
577
0
        if (data->dgram_bio != NULL) {
578
0
            *(BIO **)ptr = data->dgram_bio;
579
0
            ret = 1;
580
0
        } else {
581
0
            ret = 0;
582
0
        }
583
0
        break;
584
0
    case BIO_CTRL_DGRAM_GET_PEER:
585
0
    case BIO_CTRL_DGRAM_DETECT_PEER_ADDR:
586
0
        if (data->state != BIO_CONN_S_OK)
587
0
            conn_state(b, data); /* best effort */
588
589
0
        if (data->state >= BIO_CONN_S_CREATE_SOCKET
590
0
            && data->addr_iter != NULL
591
0
            && (dg_addr = BIO_ADDRINFO_address(data->addr_iter)) != NULL) {
592
593
0
            ret = BIO_ADDR_sockaddr_size(dg_addr);
594
0
            if (num == 0 || num > ret)
595
0
                num = ret;
596
597
0
            memcpy(ptr, dg_addr, num);
598
0
            ret = num;
599
0
        } else {
600
0
            ret = 0;
601
0
        }
602
603
0
        break;
604
0
    case BIO_CTRL_GET_RPOLL_DESCRIPTOR:
605
0
    case BIO_CTRL_GET_WPOLL_DESCRIPTOR:
606
0
        {
607
0
            BIO_POLL_DESCRIPTOR *pd = ptr;
608
609
0
            if (data->state != BIO_CONN_S_OK)
610
0
                conn_state(b, data); /* best effort */
611
612
0
            if (data->state >= BIO_CONN_S_CREATE_SOCKET) {
613
0
                pd->type        = BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD;
614
0
                pd->value.fd    = b->num;
615
0
            } else {
616
0
                ret = 0;
617
0
            }
618
0
        }
619
0
        break;
620
0
    case BIO_C_SET_NBIO:
621
0
        if (num != 0)
622
0
            data->connect_mode |= BIO_SOCK_NONBLOCK;
623
0
        else
624
0
            data->connect_mode &= ~BIO_SOCK_NONBLOCK;
625
626
0
        if (data->dgram_bio != NULL)
627
0
            ret = BIO_set_nbio(data->dgram_bio, num);
628
629
0
        break;
630
#if defined(TCP_FASTOPEN) && !defined(OPENSSL_NO_TFO)
631
    case BIO_C_SET_TFO:
632
        if (num != 0) {
633
            data->connect_mode |= BIO_SOCK_TFO;
634
            data->tfo_first = 1;
635
        } else {
636
            data->connect_mode &= ~BIO_SOCK_TFO;
637
            data->tfo_first = 0;
638
        }
639
        break;
640
#endif
641
0
    case BIO_C_SET_CONNECT_MODE:
642
0
        data->connect_mode = (int)num;
643
0
        if (num & BIO_SOCK_TFO)
644
0
            data->tfo_first = 1;
645
0
        else
646
0
            data->tfo_first = 0;
647
0
        break;
648
0
    case BIO_C_GET_FD:
649
0
        if (b->init) {
650
0
            ip = (int *)ptr;
651
0
            if (ip != NULL)
652
0
                *ip = b->num;
653
0
            ret = b->num;
654
0
        } else
655
0
            ret = -1;
656
0
        break;
657
0
    case BIO_CTRL_GET_CLOSE:
658
0
        ret = b->shutdown;
659
0
        break;
660
0
    case BIO_CTRL_SET_CLOSE:
661
0
        b->shutdown = (int)num;
662
0
        break;
663
0
    case BIO_CTRL_PENDING:
664
0
    case BIO_CTRL_WPENDING:
665
0
        ret = 0;
666
0
        break;
667
0
    case BIO_CTRL_FLUSH:
668
0
        break;
669
0
    case BIO_CTRL_DUP:
670
0
        {
671
0
            dbio = (BIO *)ptr;
672
0
            if (data->param_hostname)
673
0
                BIO_set_conn_hostname(dbio, data->param_hostname);
674
0
            if (data->param_service)
675
0
                BIO_set_conn_port(dbio, data->param_service);
676
0
            BIO_set_conn_ip_family(dbio, data->connect_family);
677
0
            BIO_set_conn_mode(dbio, data->connect_mode);
678
            /*
679
             * FIXME: the cast of the function seems unlikely to be a good
680
             * idea
681
             */
682
0
            (void)BIO_set_info_callback(dbio, data->info_callback);
683
0
        }
684
0
        break;
685
0
    case BIO_CTRL_SET_CALLBACK:
686
0
        ret = 0; /* use callback ctrl */
687
0
        break;
688
0
    case BIO_CTRL_GET_CALLBACK:
689
0
        {
690
0
            BIO_info_cb **fptr;
691
692
0
            fptr = (BIO_info_cb **)ptr;
693
0
            *fptr = data->info_callback;
694
0
        }
695
0
        break;
696
0
    case BIO_CTRL_EOF:
697
0
        ret = (b->flags & BIO_FLAGS_IN_EOF) != 0;
698
0
        break;
699
# ifndef OPENSSL_NO_KTLS
700
    case BIO_CTRL_SET_KTLS:
701
        crypto_info = (ktls_crypto_info_t *)ptr;
702
        ret = ktls_start(b->num, crypto_info, num);
703
        if (ret)
704
            BIO_set_ktls_flag(b, num);
705
        break;
706
    case BIO_CTRL_GET_KTLS_SEND:
707
        return BIO_should_ktls_flag(b, 1) != 0;
708
    case BIO_CTRL_GET_KTLS_RECV:
709
        return BIO_should_ktls_flag(b, 0) != 0;
710
    case BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG:
711
        BIO_set_ktls_ctrl_msg_flag(b);
712
        data->record_type = num;
713
        ret = 0;
714
        break;
715
    case BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG:
716
        BIO_clear_ktls_ctrl_msg_flag(b);
717
        ret = 0;
718
        break;
719
    case BIO_CTRL_SET_KTLS_TX_ZEROCOPY_SENDFILE:
720
        ret = ktls_enable_tx_zerocopy_sendfile(b->num);
721
        if (ret)
722
            BIO_set_ktls_zerocopy_sendfile_flag(b);
723
        break;
724
# endif
725
0
    default:
726
0
        ret = 0;
727
0
        break;
728
0
    }
729
0
    return ret;
730
0
}
731
732
static long conn_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
733
0
{
734
0
    long ret = 1;
735
0
    BIO_CONNECT *data;
736
737
0
    data = (BIO_CONNECT *)b->ptr;
738
739
0
    switch (cmd) {
740
0
    case BIO_CTRL_SET_CALLBACK:
741
0
        {
742
0
            data->info_callback = fp;
743
0
        }
744
0
        break;
745
0
    default:
746
0
        ret = 0;
747
0
        break;
748
0
    }
749
0
    return ret;
750
0
}
751
752
static int conn_puts(BIO *bp, const char *str)
753
0
{
754
0
    int n, ret;
755
756
0
    n = strlen(str);
757
0
    ret = conn_write(bp, str, n);
758
0
    return ret;
759
0
}
760
761
int conn_gets(BIO *bio, char *buf, int size)
762
0
{
763
0
    BIO_CONNECT *data;
764
0
    char *ptr = buf;
765
0
    int ret = 0;
766
767
0
    if (buf == NULL) {
768
0
        ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
769
0
        return -1;
770
0
    }
771
0
    if (size <= 0) {
772
0
        ERR_raise(ERR_LIB_BIO, BIO_R_INVALID_ARGUMENT);
773
0
        return -1;
774
0
    }
775
0
    *buf = '\0';
776
777
0
    if (bio == NULL || bio->ptr == NULL) {
778
0
        ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
779
0
        return -1;
780
0
    }
781
0
    data = (BIO_CONNECT *)bio->ptr;
782
0
    if (data->state != BIO_CONN_S_OK) {
783
0
        ret = conn_state(bio, data);
784
0
        if (ret <= 0)
785
0
            return ret;
786
0
    }
787
788
0
    if (data->dgram_bio != NULL) {
789
0
        ERR_raise(ERR_LIB_BIO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
790
0
        return -1;
791
0
    }
792
793
0
    clear_socket_error();
794
0
    while (size-- > 1) {
795
# ifndef OPENSSL_NO_KTLS
796
        if (BIO_get_ktls_recv(bio))
797
            ret = ktls_read_record(bio->num, ptr, 1);
798
        else
799
# endif
800
0
            ret = readsocket(bio->num, ptr, 1);
801
0
        BIO_clear_retry_flags(bio);
802
0
        if (ret <= 0) {
803
0
            if (BIO_sock_should_retry(ret))
804
0
                BIO_set_retry_read(bio);
805
0
            else if (ret == 0)
806
0
                bio->flags |= BIO_FLAGS_IN_EOF;
807
0
            break;
808
0
        }
809
0
        if (*ptr++ == '\n')
810
0
            break;
811
0
    }
812
0
    *ptr = '\0';
813
0
    return ret > 0 || (bio->flags & BIO_FLAGS_IN_EOF) != 0 ? ptr - buf : ret;
814
0
}
815
816
static int conn_sendmmsg(BIO *bio, BIO_MSG *msg, size_t stride, size_t num_msgs,
817
                         uint64_t flags, size_t *msgs_processed)
818
0
{
819
0
    int ret;
820
0
    BIO_CONNECT *data;
821
822
0
    if (bio == NULL) {
823
0
        *msgs_processed = 0;
824
0
        ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
825
0
        return 0;
826
0
    }
827
828
0
    data = (BIO_CONNECT *)bio->ptr;
829
0
    if (data->state != BIO_CONN_S_OK) {
830
0
        ret = conn_state(bio, data);
831
0
        if (ret <= 0) {
832
0
            *msgs_processed = 0;
833
0
            return 0;
834
0
        }
835
0
    }
836
837
0
    if (data->dgram_bio == NULL) {
838
0
        *msgs_processed = 0;
839
0
        ERR_raise(ERR_LIB_BIO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
840
0
        return 0;
841
0
    }
842
843
0
    return BIO_sendmmsg(data->dgram_bio, msg, stride, num_msgs,
844
0
                        flags, msgs_processed);
845
0
}
846
847
static int conn_recvmmsg(BIO *bio, BIO_MSG *msg, size_t stride, size_t num_msgs,
848
                         uint64_t flags, size_t *msgs_processed)
849
0
{
850
0
    int ret;
851
0
    BIO_CONNECT *data;
852
853
0
    if (bio == NULL) {
854
0
        *msgs_processed = 0;
855
0
        ERR_raise(ERR_LIB_BIO, ERR_R_PASSED_NULL_PARAMETER);
856
0
        return 0;
857
0
    }
858
859
0
    data = (BIO_CONNECT *)bio->ptr;
860
0
    if (data->state != BIO_CONN_S_OK) {
861
0
        ret = conn_state(bio, data);
862
0
        if (ret <= 0) {
863
0
            *msgs_processed = 0;
864
0
            return 0;
865
0
        }
866
0
    }
867
868
0
    if (data->dgram_bio == NULL) {
869
0
        *msgs_processed = 0;
870
0
        ERR_raise(ERR_LIB_BIO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
871
0
        return 0;
872
0
    }
873
874
0
    return BIO_recvmmsg(data->dgram_bio, msg, stride, num_msgs,
875
0
                        flags, msgs_processed);
876
0
}
877
878
BIO *BIO_new_connect(const char *str)
879
0
{
880
0
    BIO *ret;
881
882
0
    ret = BIO_new(BIO_s_connect());
883
0
    if (ret == NULL)
884
0
        return NULL;
885
0
    if (BIO_set_conn_hostname(ret, str))
886
0
        return ret;
887
0
    BIO_free(ret);
888
0
    return NULL;
889
0
}
890
891
#endif