summaryrefslogtreecommitdiff
path: root/src/lib/libssl/bio_ssl.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libssl/bio_ssl.c')
-rw-r--r--src/lib/libssl/bio_ssl.c545
1 files changed, 270 insertions, 275 deletions
diff --git a/src/lib/libssl/bio_ssl.c b/src/lib/libssl/bio_ssl.c
index e9552caee2..65077aaa00 100644
--- a/src/lib/libssl/bio_ssl.c
+++ b/src/lib/libssl/bio_ssl.c
@@ -72,8 +72,7 @@ static long ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2);
72static int ssl_new(BIO *h); 72static int ssl_new(BIO *h);
73static int ssl_free(BIO *data); 73static int ssl_free(BIO *data);
74static long ssl_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); 74static long ssl_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
75typedef struct bio_ssl_st 75typedef struct bio_ssl_st {
76 {
77 SSL *ssl; /* The ssl handle :-) */ 76 SSL *ssl; /* The ssl handle :-) */
78 /* re-negotiate every time the total number of bytes is this size */ 77 /* re-negotiate every time the total number of bytes is this size */
79 int num_renegotiates; 78 int num_renegotiates;
@@ -81,11 +80,10 @@ typedef struct bio_ssl_st
81 unsigned long byte_count; 80 unsigned long byte_count;
82 unsigned long renegotiate_timeout; 81 unsigned long renegotiate_timeout;
83 unsigned long last_time; 82 unsigned long last_time;
84 } BIO_SSL; 83} BIO_SSL;
85 84
86static BIO_METHOD methods_sslp= 85static BIO_METHOD methods_sslp = {
87 { 86 BIO_TYPE_SSL, "ssl",
88 BIO_TYPE_SSL,"ssl",
89 ssl_write, 87 ssl_write,
90 ssl_read, 88 ssl_read,
91 ssl_puts, 89 ssl_puts,
@@ -94,106 +92,105 @@ static BIO_METHOD methods_sslp=
94 ssl_new, 92 ssl_new,
95 ssl_free, 93 ssl_free,
96 ssl_callback_ctrl, 94 ssl_callback_ctrl,
97 }; 95};
98 96
99BIO_METHOD *BIO_f_ssl(void) 97BIO_METHOD
100 { 98*BIO_f_ssl(void)
101 return(&methods_sslp); 99{
102 } 100 return (&methods_sslp);
101}
103 102
104static int ssl_new(BIO *bi) 103static int
105 { 104ssl_new(BIO *bi)
105{
106 BIO_SSL *bs; 106 BIO_SSL *bs;
107 107
108 bs=(BIO_SSL *)OPENSSL_malloc(sizeof(BIO_SSL)); 108 bs = (BIO_SSL *)OPENSSL_malloc(sizeof(BIO_SSL));
109 if (bs == NULL) 109 if (bs == NULL) {
110 { 110 BIOerr(BIO_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
111 BIOerr(BIO_F_SSL_NEW,ERR_R_MALLOC_FAILURE); 111 return (0);
112 return(0);
113 }
114 memset(bs,0,sizeof(BIO_SSL));
115 bi->init=0;
116 bi->ptr=(char *)bs;
117 bi->flags=0;
118 return(1);
119 } 112 }
120 113 memset(bs, 0, sizeof(BIO_SSL));
121static int ssl_free(BIO *a) 114 bi->init = 0;
122 { 115 bi->ptr = (char *)bs;
116 bi->flags = 0;
117 return (1);
118}
119
120static int
121ssl_free(BIO *a)
122{
123 BIO_SSL *bs; 123 BIO_SSL *bs;
124 124
125 if (a == NULL) return(0); 125 if (a == NULL)
126 bs=(BIO_SSL *)a->ptr; 126 return (0);
127 if (bs->ssl != NULL) SSL_shutdown(bs->ssl); 127 bs = (BIO_SSL *)a->ptr;
128 if (a->shutdown) 128 if (bs->ssl != NULL)
129 { 129 SSL_shutdown(bs->ssl);
130 if (a->shutdown) {
130 if (a->init && (bs->ssl != NULL)) 131 if (a->init && (bs->ssl != NULL))
131 SSL_free(bs->ssl); 132 SSL_free(bs->ssl);
132 a->init=0; 133 a->init = 0;
133 a->flags=0; 134 a->flags = 0;
134 } 135 }
135 if (a->ptr != NULL) 136 if (a->ptr != NULL)
136 OPENSSL_free(a->ptr); 137 OPENSSL_free(a->ptr);
137 return(1); 138 return (1);
138 } 139}
139 140
140static int ssl_read(BIO *b, char *out, int outl) 141static int
141 { 142ssl_read(BIO *b, char *out, int outl)
142 int ret=1; 143{
144 int ret = 1;
143 BIO_SSL *sb; 145 BIO_SSL *sb;
144 SSL *ssl; 146 SSL *ssl;
145 int retry_reason=0; 147 int retry_reason = 0;
146 int r=0; 148 int r = 0;
147 149
148 if (out == NULL) return(0); 150 if (out == NULL)
149 sb=(BIO_SSL *)b->ptr; 151 return (0);
150 ssl=sb->ssl; 152 sb = (BIO_SSL *)b->ptr;
153 ssl = sb->ssl;
151 154
152 BIO_clear_retry_flags(b); 155 BIO_clear_retry_flags(b);
153 156
154#if 0 157#if 0
155 if (!SSL_is_init_finished(ssl)) 158 if (!SSL_is_init_finished(ssl)) {
156 {
157/* ret=SSL_do_handshake(ssl); */ 159/* ret=SSL_do_handshake(ssl); */
158 if (ret > 0) 160 if (ret > 0) {
159 {
160 161
161 outflags=(BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY); 162 outflags = (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY);
162 ret= -1; 163 ret = -1;
163 goto end; 164 goto end;
164 }
165 } 165 }
166 }
166#endif 167#endif
167/* if (ret > 0) */ 168/* if (ret > 0) */
168 ret=SSL_read(ssl,out,outl); 169 ret = SSL_read(ssl, out, outl);
169 170
170 switch (SSL_get_error(ssl,ret)) 171 switch (SSL_get_error(ssl, ret)) {
171 {
172 case SSL_ERROR_NONE: 172 case SSL_ERROR_NONE:
173 if (ret <= 0) break; 173 if (ret <= 0)
174 if (sb->renegotiate_count > 0) 174 break;
175 { 175 if (sb->renegotiate_count > 0) {
176 sb->byte_count+=ret; 176 sb->byte_count += ret;
177 if (sb->byte_count > sb->renegotiate_count) 177 if (sb->byte_count > sb->renegotiate_count) {
178 { 178 sb->byte_count = 0;
179 sb->byte_count=0;
180 sb->num_renegotiates++; 179 sb->num_renegotiates++;
181 SSL_renegotiate(ssl); 180 SSL_renegotiate(ssl);
182 r=1; 181 r = 1;
183 }
184 } 182 }
185 if ((sb->renegotiate_timeout > 0) && (!r)) 183 }
186 { 184 if ((sb->renegotiate_timeout > 0) && (!r)) {
187 unsigned long tm; 185 unsigned long tm;
188 186
189 tm=(unsigned long)time(NULL); 187 tm = (unsigned long)time(NULL);
190 if (tm > sb->last_time+sb->renegotiate_timeout) 188 if (tm > sb->last_time + sb->renegotiate_timeout) {
191 { 189 sb->last_time = tm;
192 sb->last_time=tm;
193 sb->num_renegotiates++; 190 sb->num_renegotiates++;
194 SSL_renegotiate(ssl); 191 SSL_renegotiate(ssl);
195 }
196 } 192 }
193 }
197 194
198 break; 195 break;
199 case SSL_ERROR_WANT_READ: 196 case SSL_ERROR_WANT_READ:
@@ -204,71 +201,69 @@ static int ssl_read(BIO *b, char *out, int outl)
204 break; 201 break;
205 case SSL_ERROR_WANT_X509_LOOKUP: 202 case SSL_ERROR_WANT_X509_LOOKUP:
206 BIO_set_retry_special(b); 203 BIO_set_retry_special(b);
207 retry_reason=BIO_RR_SSL_X509_LOOKUP; 204 retry_reason = BIO_RR_SSL_X509_LOOKUP;
208 break; 205 break;
209 case SSL_ERROR_WANT_ACCEPT: 206 case SSL_ERROR_WANT_ACCEPT:
210 BIO_set_retry_special(b); 207 BIO_set_retry_special(b);
211 retry_reason=BIO_RR_ACCEPT; 208 retry_reason = BIO_RR_ACCEPT;
212 break; 209 break;
213 case SSL_ERROR_WANT_CONNECT: 210 case SSL_ERROR_WANT_CONNECT:
214 BIO_set_retry_special(b); 211 BIO_set_retry_special(b);
215 retry_reason=BIO_RR_CONNECT; 212 retry_reason = BIO_RR_CONNECT;
216 break; 213 break;
217 case SSL_ERROR_SYSCALL: 214 case SSL_ERROR_SYSCALL:
218 case SSL_ERROR_SSL: 215 case SSL_ERROR_SSL:
219 case SSL_ERROR_ZERO_RETURN: 216 case SSL_ERROR_ZERO_RETURN:
220 default: 217 default:
221 break; 218 break;
222 }
223
224 b->retry_reason=retry_reason;
225 return(ret);
226 } 219 }
227 220
228static int ssl_write(BIO *b, const char *out, int outl) 221 b->retry_reason = retry_reason;
229 { 222 return (ret);
230 int ret,r=0; 223}
231 int retry_reason=0; 224
225static int
226ssl_write(BIO *b, const char *out, int outl)
227{
228 int ret, r = 0;
229 int retry_reason = 0;
232 SSL *ssl; 230 SSL *ssl;
233 BIO_SSL *bs; 231 BIO_SSL *bs;
234 232
235 if (out == NULL) return(0); 233 if (out == NULL)
236 bs=(BIO_SSL *)b->ptr; 234 return (0);
237 ssl=bs->ssl; 235 bs = (BIO_SSL *)b->ptr;
236 ssl = bs->ssl;
238 237
239 BIO_clear_retry_flags(b); 238 BIO_clear_retry_flags(b);
240 239
241/* ret=SSL_do_handshake(ssl); 240/* ret=SSL_do_handshake(ssl);
242 if (ret > 0) */ 241 if (ret > 0) */
243 ret=SSL_write(ssl,out,outl); 242 ret = SSL_write(ssl, out, outl);
244 243
245 switch (SSL_get_error(ssl,ret)) 244 switch (SSL_get_error(ssl, ret)) {
246 {
247 case SSL_ERROR_NONE: 245 case SSL_ERROR_NONE:
248 if (ret <= 0) break; 246 if (ret <= 0)
249 if (bs->renegotiate_count > 0) 247 break;
250 { 248 if (bs->renegotiate_count > 0) {
251 bs->byte_count+=ret; 249 bs->byte_count += ret;
252 if (bs->byte_count > bs->renegotiate_count) 250 if (bs->byte_count > bs->renegotiate_count) {
253 { 251 bs->byte_count = 0;
254 bs->byte_count=0;
255 bs->num_renegotiates++; 252 bs->num_renegotiates++;
256 SSL_renegotiate(ssl); 253 SSL_renegotiate(ssl);
257 r=1; 254 r = 1;
258 }
259 } 255 }
260 if ((bs->renegotiate_timeout > 0) && (!r)) 256 }
261 { 257 if ((bs->renegotiate_timeout > 0) && (!r)) {
262 unsigned long tm; 258 unsigned long tm;
263 259
264 tm=(unsigned long)time(NULL); 260 tm = (unsigned long)time(NULL);
265 if (tm > bs->last_time+bs->renegotiate_timeout) 261 if (tm > bs->last_time + bs->renegotiate_timeout) {
266 { 262 bs->last_time = tm;
267 bs->last_time=tm;
268 bs->num_renegotiates++; 263 bs->num_renegotiates++;
269 SSL_renegotiate(ssl); 264 SSL_renegotiate(ssl);
270 }
271 } 265 }
266 }
272 break; 267 break;
273 case SSL_ERROR_WANT_WRITE: 268 case SSL_ERROR_WANT_WRITE:
274 BIO_set_retry_write(b); 269 BIO_set_retry_write(b);
@@ -278,34 +273,34 @@ static int ssl_write(BIO *b, const char *out, int outl)
278 break; 273 break;
279 case SSL_ERROR_WANT_X509_LOOKUP: 274 case SSL_ERROR_WANT_X509_LOOKUP:
280 BIO_set_retry_special(b); 275 BIO_set_retry_special(b);
281 retry_reason=BIO_RR_SSL_X509_LOOKUP; 276 retry_reason = BIO_RR_SSL_X509_LOOKUP;
282 break; 277 break;
283 case SSL_ERROR_WANT_CONNECT: 278 case SSL_ERROR_WANT_CONNECT:
284 BIO_set_retry_special(b); 279 BIO_set_retry_special(b);
285 retry_reason=BIO_RR_CONNECT; 280 retry_reason = BIO_RR_CONNECT;
286 case SSL_ERROR_SYSCALL: 281 case SSL_ERROR_SYSCALL:
287 case SSL_ERROR_SSL: 282 case SSL_ERROR_SSL:
288 default: 283 default:
289 break; 284 break;
290 }
291
292 b->retry_reason=retry_reason;
293 return(ret);
294 } 285 }
295 286
296static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr) 287 b->retry_reason = retry_reason;
297 { 288 return (ret);
298 SSL **sslp,*ssl; 289}
290
291static long
292ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
293{
294 SSL **sslp, *ssl;
299 BIO_SSL *bs; 295 BIO_SSL *bs;
300 BIO *dbio,*bio; 296 BIO *dbio, *bio;
301 long ret=1; 297 long ret = 1;
302 298
303 bs=(BIO_SSL *)b->ptr; 299 bs = (BIO_SSL *)b->ptr;
304 ssl=bs->ssl; 300 ssl = bs->ssl;
305 if ((ssl == NULL) && (cmd != BIO_C_SET_SSL)) 301 if ((ssl == NULL) && (cmd != BIO_C_SET_SSL))
306 return(0); 302 return (0);
307 switch (cmd) 303 switch (cmd) {
308 {
309 case BIO_CTRL_RESET: 304 case BIO_CTRL_RESET:
310 SSL_shutdown(ssl); 305 SSL_shutdown(ssl);
311 306
@@ -317,14 +312,14 @@ static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
317 SSL_clear(ssl); 312 SSL_clear(ssl);
318 313
319 if (b->next_bio != NULL) 314 if (b->next_bio != NULL)
320 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 315 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
321 else if (ssl->rbio != NULL) 316 else if (ssl->rbio != NULL)
322 ret=BIO_ctrl(ssl->rbio,cmd,num,ptr); 317 ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
323 else 318 else
324 ret=1; 319 ret = 1;
325 break; 320 break;
326 case BIO_CTRL_INFO: 321 case BIO_CTRL_INFO:
327 ret=0; 322 ret = 0;
328 break; 323 break;
329 case BIO_C_SSL_MODE: 324 case BIO_C_SSL_MODE:
330 if (num) /* client mode */ 325 if (num) /* client mode */
@@ -333,273 +328,273 @@ static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
333 SSL_set_accept_state(ssl); 328 SSL_set_accept_state(ssl);
334 break; 329 break;
335 case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT: 330 case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT:
336 ret=bs->renegotiate_timeout; 331 ret = bs->renegotiate_timeout;
337 if (num < 60) num=5; 332 if (num < 60)
338 bs->renegotiate_timeout=(unsigned long)num; 333 num = 5;
339 bs->last_time=(unsigned long)time(NULL); 334 bs->renegotiate_timeout = (unsigned long)num;
335 bs->last_time = (unsigned long)time(NULL);
340 break; 336 break;
341 case BIO_C_SET_SSL_RENEGOTIATE_BYTES: 337 case BIO_C_SET_SSL_RENEGOTIATE_BYTES:
342 ret=bs->renegotiate_count; 338 ret = bs->renegotiate_count;
343 if ((long)num >=512) 339 if ((long)num >=512)
344 bs->renegotiate_count=(unsigned long)num; 340 bs->renegotiate_count = (unsigned long)num;
345 break; 341 break;
346 case BIO_C_GET_SSL_NUM_RENEGOTIATES: 342 case BIO_C_GET_SSL_NUM_RENEGOTIATES:
347 ret=bs->num_renegotiates; 343 ret = bs->num_renegotiates;
348 break; 344 break;
349 case BIO_C_SET_SSL: 345 case BIO_C_SET_SSL:
350 if (ssl != NULL) 346 if (ssl != NULL) {
351 {
352 ssl_free(b); 347 ssl_free(b);
353 if (!ssl_new(b)) 348 if (!ssl_new(b))
354 return 0; 349 return 0;
355 } 350 }
356 b->shutdown=(int)num; 351 b->shutdown = (int)num;
357 ssl=(SSL *)ptr; 352 ssl = (SSL *)ptr;
358 ((BIO_SSL *)b->ptr)->ssl=ssl; 353 ((BIO_SSL *)b->ptr)->ssl = ssl;
359 bio=SSL_get_rbio(ssl); 354 bio = SSL_get_rbio(ssl);
360 if (bio != NULL) 355 if (bio != NULL) {
361 {
362 if (b->next_bio != NULL) 356 if (b->next_bio != NULL)
363 BIO_push(bio,b->next_bio); 357 BIO_push(bio, b->next_bio);
364 b->next_bio=bio; 358 b->next_bio = bio;
365 CRYPTO_add(&bio->references,1,CRYPTO_LOCK_BIO); 359 CRYPTO_add(&bio->references, 1, CRYPTO_LOCK_BIO);
366 } 360 }
367 b->init=1; 361 b->init = 1;
368 break; 362 break;
369 case BIO_C_GET_SSL: 363 case BIO_C_GET_SSL:
370 if (ptr != NULL) 364 if (ptr != NULL) {
371 { 365 sslp = (SSL **)ptr;
372 sslp=(SSL **)ptr; 366 *sslp = ssl;
373 *sslp=ssl; 367 } else
374 } 368 ret = 0;
375 else
376 ret=0;
377 break; 369 break;
378 case BIO_CTRL_GET_CLOSE: 370 case BIO_CTRL_GET_CLOSE:
379 ret=b->shutdown; 371 ret = b->shutdown;
380 break; 372 break;
381 case BIO_CTRL_SET_CLOSE: 373 case BIO_CTRL_SET_CLOSE:
382 b->shutdown=(int)num; 374 b->shutdown = (int)num;
383 break; 375 break;
384 case BIO_CTRL_WPENDING: 376 case BIO_CTRL_WPENDING:
385 ret=BIO_ctrl(ssl->wbio,cmd,num,ptr); 377 ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
386 break; 378 break;
387 case BIO_CTRL_PENDING: 379 case BIO_CTRL_PENDING:
388 ret=SSL_pending(ssl); 380 ret = SSL_pending(ssl);
389 if (ret == 0) 381 if (ret == 0)
390 ret=BIO_pending(ssl->rbio); 382 ret = BIO_pending(ssl->rbio);
391 break; 383 break;
392 case BIO_CTRL_FLUSH: 384 case BIO_CTRL_FLUSH:
393 BIO_clear_retry_flags(b); 385 BIO_clear_retry_flags(b);
394 ret=BIO_ctrl(ssl->wbio,cmd,num,ptr); 386 ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
395 BIO_copy_next_retry(b); 387 BIO_copy_next_retry(b);
396 break; 388 break;
397 case BIO_CTRL_PUSH: 389 case BIO_CTRL_PUSH:
398 if ((b->next_bio != NULL) && (b->next_bio != ssl->rbio)) 390 if ((b->next_bio != NULL) && (b->next_bio != ssl->rbio)) {
399 { 391 SSL_set_bio(ssl, b->next_bio, b->next_bio);
400 SSL_set_bio(ssl,b->next_bio,b->next_bio); 392 CRYPTO_add(&b->next_bio->references, 1, CRYPTO_LOCK_BIO);
401 CRYPTO_add(&b->next_bio->references,1,CRYPTO_LOCK_BIO); 393 }
402 }
403 break; 394 break;
404 case BIO_CTRL_POP: 395 case BIO_CTRL_POP:
405 /* Only detach if we are the BIO explicitly being popped */ 396 /* Only detach if we are the BIO explicitly being popped */
406 if (b == ptr) 397 if (b == ptr) {
407 {
408 /* Shouldn't happen in practice because the 398 /* Shouldn't happen in practice because the
409 * rbio and wbio are the same when pushed. 399 * rbio and wbio are the same when pushed.
410 */ 400 */
411 if (ssl->rbio != ssl->wbio) 401 if (ssl->rbio != ssl->wbio)
412 BIO_free_all(ssl->wbio); 402 BIO_free_all(ssl->wbio);
413 if (b->next_bio != NULL) 403 if (b->next_bio != NULL)
414 CRYPTO_add(&b->next_bio->references,-1,CRYPTO_LOCK_BIO); 404 CRYPTO_add(&b->next_bio->references, -1, CRYPTO_LOCK_BIO);
415 ssl->wbio=NULL; 405 ssl->wbio = NULL;
416 ssl->rbio=NULL; 406 ssl->rbio = NULL;
417 } 407 }
418 break; 408 break;
419 case BIO_C_DO_STATE_MACHINE: 409 case BIO_C_DO_STATE_MACHINE:
420 BIO_clear_retry_flags(b); 410 BIO_clear_retry_flags(b);
421 411
422 b->retry_reason=0; 412 b->retry_reason = 0;
423 ret=(int)SSL_do_handshake(ssl); 413 ret = (int)SSL_do_handshake(ssl);
424 414
425 switch (SSL_get_error(ssl,(int)ret)) 415 switch (SSL_get_error(ssl,(int)ret)) {
426 {
427 case SSL_ERROR_WANT_READ: 416 case SSL_ERROR_WANT_READ:
428 BIO_set_flags(b, 417 BIO_set_flags(b,
429 BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY); 418 BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY);
430 break; 419 break;
431 case SSL_ERROR_WANT_WRITE: 420 case SSL_ERROR_WANT_WRITE:
432 BIO_set_flags(b, 421 BIO_set_flags(b,
433 BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY); 422 BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY);
434 break; 423 break;
435 case SSL_ERROR_WANT_CONNECT: 424 case SSL_ERROR_WANT_CONNECT:
436 BIO_set_flags(b, 425 BIO_set_flags(b,
437 BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY); 426 BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY);
438 b->retry_reason=b->next_bio->retry_reason; 427 b->retry_reason = b->next_bio->retry_reason;
439 break; 428 break;
440 default: 429 default:
441 break; 430 break;
442 } 431 }
443 break; 432 break;
444 case BIO_CTRL_DUP: 433 case BIO_CTRL_DUP:
445 dbio=(BIO *)ptr; 434 dbio = (BIO *)ptr;
446 if (((BIO_SSL *)dbio->ptr)->ssl != NULL) 435 if (((BIO_SSL *)dbio->ptr)->ssl != NULL)
447 SSL_free(((BIO_SSL *)dbio->ptr)->ssl); 436 SSL_free(((BIO_SSL *)dbio->ptr)->ssl);
448 ((BIO_SSL *)dbio->ptr)->ssl=SSL_dup(ssl); 437 ((BIO_SSL *)dbio->ptr)->ssl = SSL_dup(ssl);
449 ((BIO_SSL *)dbio->ptr)->renegotiate_count= 438 ((BIO_SSL *)dbio->ptr)->renegotiate_count =
450 ((BIO_SSL *)b->ptr)->renegotiate_count; 439 ((BIO_SSL *)b->ptr)->renegotiate_count;
451 ((BIO_SSL *)dbio->ptr)->byte_count= 440 ((BIO_SSL *)dbio->ptr)->byte_count =
452 ((BIO_SSL *)b->ptr)->byte_count; 441 ((BIO_SSL *)b->ptr)->byte_count;
453 ((BIO_SSL *)dbio->ptr)->renegotiate_timeout= 442 ((BIO_SSL *)dbio->ptr)->renegotiate_timeout =
454 ((BIO_SSL *)b->ptr)->renegotiate_timeout; 443 ((BIO_SSL *)b->ptr)->renegotiate_timeout;
455 ((BIO_SSL *)dbio->ptr)->last_time= 444 ((BIO_SSL *)dbio->ptr)->last_time =
456 ((BIO_SSL *)b->ptr)->last_time; 445 ((BIO_SSL *)b->ptr)->last_time;
457 ret=(((BIO_SSL *)dbio->ptr)->ssl != NULL); 446 ret = (((BIO_SSL *)dbio->ptr)->ssl != NULL);
458 break; 447 break;
459 case BIO_C_GET_FD: 448 case BIO_C_GET_FD:
460 ret=BIO_ctrl(ssl->rbio,cmd,num,ptr); 449 ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
461 break; 450 break;
462 case BIO_CTRL_SET_CALLBACK: 451 case BIO_CTRL_SET_CALLBACK:
463 { 452 {
464#if 0 /* FIXME: Should this be used? -- Richard Levitte */ 453#if 0 /* FIXME: Should this be used? -- Richard Levitte */
465 SSLerr(SSL_F_SSL_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); 454 SSLerr(SSL_F_SSL_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
466 ret = -1; 455 ret = -1;
467#else 456#else
468 ret=0; 457 ret = 0;
469#endif 458#endif
470 } 459 }
471 break; 460 break;
472 case BIO_CTRL_GET_CALLBACK: 461 case BIO_CTRL_GET_CALLBACK:
473 { 462 {
474 void (**fptr)(const SSL *xssl,int type,int val); 463 void (**fptr)(const SSL *xssl, int type, int val);
475 464
476 fptr=(void (**)(const SSL *xssl,int type,int val))ptr; 465 fptr = (void (**)(const SSL *xssl, int type, int val))ptr;
477 *fptr=SSL_get_info_callback(ssl); 466 *fptr = SSL_get_info_callback(ssl);
478 } 467 }
479 break; 468 break;
480 default: 469 default:
481 ret=BIO_ctrl(ssl->rbio,cmd,num,ptr); 470 ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
482 break; 471 break;
483 }
484 return(ret);
485 } 472 }
473 return (ret);
474}
486 475
487static long ssl_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) 476static long
488 { 477ssl_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
478{
489 SSL *ssl; 479 SSL *ssl;
490 BIO_SSL *bs; 480 BIO_SSL *bs;
491 long ret=1; 481 long ret = 1;
492 482
493 bs=(BIO_SSL *)b->ptr; 483 bs = (BIO_SSL *)b->ptr;
494 ssl=bs->ssl; 484 ssl = bs->ssl;
495 switch (cmd) 485 switch (cmd) {
496 {
497 case BIO_CTRL_SET_CALLBACK: 486 case BIO_CTRL_SET_CALLBACK:
498 { 487 {
499 /* FIXME: setting this via a completely different prototype 488 /* FIXME: setting this via a completely different prototype
500 seems like a crap idea */ 489 seems like a crap idea */
501 SSL_set_info_callback(ssl,(void (*)(const SSL *,int,int))fp); 490 SSL_set_info_callback(ssl,(void (*)(const SSL *, int, int))fp);
502 } 491 }
503 break; 492 break;
504 default: 493 default:
505 ret=BIO_callback_ctrl(ssl->rbio,cmd,fp); 494 ret = BIO_callback_ctrl(ssl->rbio, cmd, fp);
506 break; 495 break;
507 }
508 return(ret);
509 } 496 }
510 497 return (ret);
511static int ssl_puts(BIO *bp, const char *str) 498}
512 { 499
513 int n,ret; 500static int
514 501ssl_puts(BIO *bp, const char *str)
515 n=strlen(str); 502{
516 ret=BIO_write(bp,str,n); 503 int n, ret;
517 return(ret); 504
518 } 505 n = strlen(str);
519 506 ret = BIO_write(bp, str, n);
520BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx) 507 return (ret);
521 { 508}
509
510BIO
511*BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
512{
522#ifndef OPENSSL_NO_SOCK 513#ifndef OPENSSL_NO_SOCK
523 BIO *ret=NULL,*buf=NULL,*ssl=NULL; 514 BIO *ret = NULL, *buf = NULL, *ssl = NULL;
524 515
525 if ((buf=BIO_new(BIO_f_buffer())) == NULL) 516 if ((buf = BIO_new(BIO_f_buffer())) == NULL)
526 return(NULL); 517 return (NULL);
527 if ((ssl=BIO_new_ssl_connect(ctx)) == NULL) 518 if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)
528 goto err; 519 goto err;
529 if ((ret=BIO_push(buf,ssl)) == NULL) 520 if ((ret = BIO_push(buf, ssl)) == NULL)
530 goto err; 521 goto err;
531 return(ret); 522 return (ret);
532err: 523err:
533 if (buf != NULL) BIO_free(buf); 524 if (buf != NULL)
534 if (ssl != NULL) BIO_free(ssl); 525 BIO_free(buf);
526 if (ssl != NULL)
527 BIO_free(ssl);
535#endif 528#endif
536 return(NULL); 529 return (NULL);
537 } 530}
538 531
539BIO *BIO_new_ssl_connect(SSL_CTX *ctx) 532BIO
540 { 533*BIO_new_ssl_connect(SSL_CTX *ctx)
534{
541#ifndef OPENSSL_NO_SOCK 535#ifndef OPENSSL_NO_SOCK
542 BIO *ret=NULL,*con=NULL,*ssl=NULL; 536 BIO *ret = NULL, *con = NULL, *ssl = NULL;
543 537
544 if ((con=BIO_new(BIO_s_connect())) == NULL) 538 if ((con = BIO_new(BIO_s_connect())) == NULL)
545 return(NULL); 539 return (NULL);
546 if ((ssl=BIO_new_ssl(ctx,1)) == NULL) 540 if ((ssl = BIO_new_ssl(ctx, 1)) == NULL)
547 goto err; 541 goto err;
548 if ((ret=BIO_push(ssl,con)) == NULL) 542 if ((ret = BIO_push(ssl, con)) == NULL)
549 goto err; 543 goto err;
550 return(ret); 544 return (ret);
551err: 545err:
552 if (con != NULL) BIO_free(con); 546 if (con != NULL)
547 BIO_free(con);
553#endif 548#endif
554 return(NULL); 549 return (NULL);
555 } 550}
556 551
557BIO *BIO_new_ssl(SSL_CTX *ctx, int client) 552BIO
558 { 553*BIO_new_ssl(SSL_CTX *ctx, int client)
554{
559 BIO *ret; 555 BIO *ret;
560 SSL *ssl; 556 SSL *ssl;
561 557
562 if ((ret=BIO_new(BIO_f_ssl())) == NULL) 558 if ((ret = BIO_new(BIO_f_ssl())) == NULL)
563 return(NULL); 559 return (NULL);
564 if ((ssl=SSL_new(ctx)) == NULL) 560 if ((ssl = SSL_new(ctx)) == NULL) {
565 {
566 BIO_free(ret); 561 BIO_free(ret);
567 return(NULL); 562 return (NULL);
568 } 563 }
569 if (client) 564 if (client)
570 SSL_set_connect_state(ssl); 565 SSL_set_connect_state(ssl);
571 else 566 else
572 SSL_set_accept_state(ssl); 567 SSL_set_accept_state(ssl);
573
574 BIO_set_ssl(ret,ssl,BIO_CLOSE);
575 return(ret);
576 }
577 568
578int BIO_ssl_copy_session_id(BIO *t, BIO *f) 569 BIO_set_ssl(ret, ssl, BIO_CLOSE);
579 { 570 return (ret);
580 t=BIO_find_type(t,BIO_TYPE_SSL); 571}
581 f=BIO_find_type(f,BIO_TYPE_SSL); 572
573int
574BIO_ssl_copy_session_id(BIO *t, BIO *f)
575{
576 t = BIO_find_type(t, BIO_TYPE_SSL);
577 f = BIO_find_type(f, BIO_TYPE_SSL);
582 if ((t == NULL) || (f == NULL)) 578 if ((t == NULL) || (f == NULL))
583 return(0); 579 return (0);
584 if ( (((BIO_SSL *)t->ptr)->ssl == NULL) || 580 if ((((BIO_SSL *)t->ptr)->ssl == NULL) ||
585 (((BIO_SSL *)f->ptr)->ssl == NULL)) 581 (((BIO_SSL *)f->ptr)->ssl == NULL))
586 return(0); 582 return (0);
587 SSL_copy_session_id(((BIO_SSL *)t->ptr)->ssl,((BIO_SSL *)f->ptr)->ssl); 583 SSL_copy_session_id(((BIO_SSL *)t->ptr)->ssl,((BIO_SSL *)f->ptr)->ssl);
588 return(1); 584 return (1);
589 } 585}
590 586
591void BIO_ssl_shutdown(BIO *b) 587void
592 { 588BIO_ssl_shutdown(BIO *b)
589{
593 SSL *s; 590 SSL *s;
594 591
595 while (b != NULL) 592 while (b != NULL) {
596 { 593 if (b->method->type == BIO_TYPE_SSL) {
597 if (b->method->type == BIO_TYPE_SSL) 594 s = ((BIO_SSL *)b->ptr)->ssl;
598 {
599 s=((BIO_SSL *)b->ptr)->ssl;
600 SSL_shutdown(s); 595 SSL_shutdown(s);
601 break; 596 break;
602 }
603 b=b->next_bio;
604 } 597 }
598 b = b->next_bio;
605 } 599 }
600}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-14 17:01:55 +0000