1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <contrib/restricted/google/boringssl/include/openssl/bio.h>
#if !defined(OPENSSL_NO_SOCK)
#include <fcntl.h>
#include <string.h>
#if !defined(OPENSSL_WINDOWS)
#include <unistd.h>
#else
#include <winsock2.h>
OPENSSL_MSVC_PRAGMA(comment(lib, "Ws2_32.lib"))
#endif
#include "internal.h"
using namespace bssl;
#if !defined(OPENSSL_WINDOWS)
static int closesocket(int sock) { return close(sock); }
#endif
static int sock_free(BIO *bio) {
if (BIO_get_shutdown(bio)) {
if (BIO_get_init(bio)) {
closesocket(FromOpaque(bio)->num);
}
BIO_set_init(bio, 0);
BIO_clear_retry_flags(bio);
}
return 1;
}
static int sock_read(BIO *b, char *out, int outl) {
if (out == nullptr) {
return 0;
}
bio_clear_socket_error();
#if defined(OPENSSL_WINDOWS)
int ret = recv(FromOpaque(b)->num, out, outl, 0);
#else
int ret = (int)read(FromOpaque(b)->num, out, outl);
#endif
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (bio_socket_should_retry(ret)) {
BIO_set_retry_read(b);
}
}
return ret;
}
static int sock_write(BIO *b, const char *in, int inl) {
bio_clear_socket_error();
#if defined(OPENSSL_WINDOWS)
int ret = send(FromOpaque(b)->num, in, inl, 0);
#else
int ret = (int)write(FromOpaque(b)->num, in, inl);
#endif
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (bio_socket_should_retry(ret)) {
BIO_set_retry_write(b);
}
}
return ret;
}
static long sock_ctrl(BIO *b, int cmd, long num, void *ptr) {
switch (cmd) {
case BIO_C_SET_FD:
sock_free(b);
FromOpaque(b)->num = *static_cast<int *>(ptr);
BIO_set_shutdown(b, static_cast<int>(num));
BIO_set_init(b, 1);
return 1;
case BIO_C_GET_FD:
if (BIO_get_init(b)) {
int *out = static_cast<int *>(ptr);
if (out != nullptr) {
*out = FromOpaque(b)->num;
}
return FromOpaque(b)->num;
}
return -1;
case BIO_CTRL_GET_CLOSE:
return BIO_get_shutdown(b);
case BIO_CTRL_SET_CLOSE:
BIO_set_shutdown(b, static_cast<int>(num));
return 1;
case BIO_CTRL_FLUSH:
return 1;
default:
return 0;
}
}
static const BIO_METHOD methods_sockp = {
BIO_TYPE_SOCKET,
"socket",
sock_write,
sock_read,
nullptr /* gets, */,
sock_ctrl,
nullptr /* create */,
sock_free,
nullptr /* callback_ctrl */,
};
const BIO_METHOD *BIO_s_socket() { return &methods_sockp; }
BIO *BIO_new_socket(int fd, int close_flag) {
BIO *ret;
ret = BIO_new(BIO_s_socket());
if (ret == nullptr) {
return nullptr;
}
BIO_set_fd(ret, fd, close_flag);
return ret;
}
// These functions are provided solely for compatibility with software that
// tries to copy and then modify |BIO_s_socket|. See bio.h for details.
// PostgreSQL's use makes several fragile assumptions on |BIO_s_socket|:
//
// - We do not store anything in |BIO_set_data|. (Broken in upstream OpenSSL,
// which broke PostgreSQL.)
// - We do not store anything in |BIO_set_app_data|.
// - |BIO_s_socket| is implemented internally using the non-|size_t|-clean
// I/O functions rather than the |size_t|-clean ones.
// - |BIO_METHOD| never gains another function pointer that is used in concert
// with any of the functions here.
//
// Some other projects doing similar things use |BIO_meth_get_read| and
// |BIO_meth_get_write| and in turn assume that |BIO_s_socket| has not been
// ported to the |size_t|-clean |BIO_read_ex| and |BIO_write_ex|. (Not yet
// implemented in BoringSSL.)
//
// This is hopelessly fragile. PostgreSQL 18 will include a fix to stop using
// these APIs, but older versions and other software remain impacted, so we
// implement these functions, but only support |BIO_s_socket|. For now they just
// return the underlying functions, but if we ever need to break the above
// assumptions, we can return an older, frozen version of |BIO_s_socket|.
// Limiting to exactly one allowed |BIO_METHOD| lets us do this.
//
// These functions are also deprecated in upstream OpenSSL. See
// https://github.com/openssl/openssl/issues/26047
//
// TODO(davidben): Once Folly and all versions of PostgreSQL we care about are
// updated or patched, remove these functions.
int (*BIO_meth_get_write(const BIO_METHOD *method))(BIO *, const char *, int) {
BSSL_CHECK(method == BIO_s_socket());
return method->bwrite;
}
int (*BIO_meth_get_read(const BIO_METHOD *method))(BIO *, char *, int) {
BSSL_CHECK(method == BIO_s_socket());
return method->bread;
}
int (*BIO_meth_get_gets(const BIO_METHOD *method))(BIO *, char *, int) {
BSSL_CHECK(method == BIO_s_socket());
return method->bgets;
}
int (*BIO_meth_get_puts(const BIO_METHOD *method))(BIO *, const char *) {
BSSL_CHECK(method == BIO_s_socket());
return nullptr;
}
long (*BIO_meth_get_ctrl(const BIO_METHOD *method))(BIO *, int, long, void *) {
BSSL_CHECK(method == BIO_s_socket());
return method->ctrl;
}
int (*BIO_meth_get_create(const BIO_METHOD *method))(BIO *) {
BSSL_CHECK(method == BIO_s_socket());
return method->create;
}
int (*BIO_meth_get_destroy(const BIO_METHOD *method))(BIO *) {
BSSL_CHECK(method == BIO_s_socket());
return method->destroy;
}
long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *method))(BIO *, int,
bio_info_cb) {
BSSL_CHECK(method == BIO_s_socket());
return method->callback_ctrl;
}
#endif // OPENSSL_NO_SOCK
|
