Move BIO index lock creation
[openssl.git] / crypto / bio / bio_lib.c
1 /*
2  * Copyright 1995-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 <stdio.h>
11 #include <errno.h>
12 #include <openssl/crypto.h>
13 #include "bio_lcl.h"
14 #include "internal/cryptlib.h"
15
16 BIO *BIO_new(const BIO_METHOD *method)
17 {
18     BIO *bio = OPENSSL_zalloc(sizeof(*bio));
19
20     if (bio == NULL) {
21         BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
22         return (NULL);
23     }
24
25     bio->method = method;
26     bio->shutdown = 1;
27     bio->references = 1;
28
29     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data))
30         goto err;
31
32     bio->lock = CRYPTO_THREAD_lock_new();
33     if (bio->lock == NULL) {
34         BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
35         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
36         goto err;
37     }
38
39     if (method->create != NULL && !method->create(bio)) {
40         BIOerr(BIO_F_BIO_NEW, ERR_R_INIT_FAIL);
41         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
42         CRYPTO_THREAD_lock_free(bio->lock);
43         goto err;
44     }
45
46     return bio;
47
48 err:
49     OPENSSL_free(bio);
50     return NULL;
51 }
52
53 int BIO_free(BIO *a)
54 {
55     int i;
56
57     if (a == NULL)
58         return 0;
59
60     if (CRYPTO_atomic_add(&a->references, -1, &i, a->lock) <= 0)
61         return 0;
62
63     REF_PRINT_COUNT("BIO", a);
64     if (i > 0)
65         return 1;
66     REF_ASSERT_ISNT(i < 0);
67     if ((a->callback != NULL) &&
68         ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
69         return i;
70
71     if ((a->method != NULL) && (a->method->destroy != NULL))
72         a->method->destroy(a);
73
74     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
75
76     CRYPTO_THREAD_lock_free(a->lock);
77
78     OPENSSL_free(a);
79
80     return 1;
81 }
82
83 void BIO_set_data(BIO *a, void *ptr)
84 {
85     a->ptr = ptr;
86 }
87
88 void *BIO_get_data(BIO *a)
89 {
90     return a->ptr;
91 }
92
93 void BIO_set_init(BIO *a, int init)
94 {
95     a->init = init;
96 }
97
98 int BIO_get_init(BIO *a)
99 {
100     return a->init;
101 }
102
103 void BIO_set_shutdown(BIO *a, int shut)
104 {
105     a->shutdown = shut;
106 }
107
108 int BIO_get_shutdown(BIO *a)
109 {
110     return a->shutdown;
111 }
112
113 void BIO_vfree(BIO *a)
114 {
115     BIO_free(a);
116 }
117
118 int BIO_up_ref(BIO *a)
119 {
120     int i;
121
122     if (CRYPTO_atomic_add(&a->references, 1, &i, a->lock) <= 0)
123         return 0;
124
125     REF_PRINT_COUNT("BIO", a);
126     REF_ASSERT_ISNT(i < 2);
127     return ((i > 1) ? 1 : 0);
128 }
129
130 void BIO_clear_flags(BIO *b, int flags)
131 {
132     b->flags &= ~flags;
133 }
134
135 int BIO_test_flags(const BIO *b, int flags)
136 {
137     return (b->flags & flags);
138 }
139
140 void BIO_set_flags(BIO *b, int flags)
141 {
142     b->flags |= flags;
143 }
144
145 long (*BIO_get_callback(const BIO *b)) (struct bio_st *, int, const char *,
146                                         int, long, long) {
147     return b->callback;
148 }
149
150 void BIO_set_callback(BIO *b,
151                       long (*cb) (struct bio_st *, int, const char *, int,
152                                   long, long))
153 {
154     b->callback = cb;
155 }
156
157 void BIO_set_callback_arg(BIO *b, char *arg)
158 {
159     b->cb_arg = arg;
160 }
161
162 char *BIO_get_callback_arg(const BIO *b)
163 {
164     return b->cb_arg;
165 }
166
167 const char *BIO_method_name(const BIO *b)
168 {
169     return b->method->name;
170 }
171
172 int BIO_method_type(const BIO *b)
173 {
174     return b->method->type;
175 }
176
177 int BIO_read(BIO *b, void *out, int outl)
178 {
179     int i;
180     long (*cb) (BIO *, int, const char *, int, long, long);
181
182     if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
183         BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
184         return (-2);
185     }
186
187     cb = b->callback;
188     if ((cb != NULL) &&
189         ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0))
190         return (i);
191
192     if (!b->init) {
193         BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
194         return (-2);
195     }
196
197     i = b->method->bread(b, out, outl);
198
199     if (i > 0)
200         b->num_read += (uint64_t)i;
201
202     if (cb != NULL)
203         i = (int)cb(b, BIO_CB_READ | BIO_CB_RETURN, out, outl, 0L, (long)i);
204     return (i);
205 }
206
207 int BIO_write(BIO *b, const void *in, int inl)
208 {
209     int i;
210     long (*cb) (BIO *, int, const char *, int, long, long);
211
212     if (b == NULL)
213         return (0);
214
215     cb = b->callback;
216     if ((b->method == NULL) || (b->method->bwrite == NULL)) {
217         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNSUPPORTED_METHOD);
218         return (-2);
219     }
220
221     if ((cb != NULL) &&
222         ((i = (int)cb(b, BIO_CB_WRITE, in, inl, 0L, 1L)) <= 0))
223         return (i);
224
225     if (!b->init) {
226         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNINITIALIZED);
227         return (-2);
228     }
229
230     i = b->method->bwrite(b, in, inl);
231
232     if (i > 0)
233         b->num_write += (uint64_t)i;
234
235     if (cb != NULL)
236         i = (int)cb(b, BIO_CB_WRITE | BIO_CB_RETURN, in, inl, 0L, (long)i);
237     return (i);
238 }
239
240 int BIO_puts(BIO *b, const char *in)
241 {
242     int i;
243     long (*cb) (BIO *, int, const char *, int, long, long);
244
245     if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) {
246         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD);
247         return (-2);
248     }
249
250     cb = b->callback;
251
252     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0))
253         return (i);
254
255     if (!b->init) {
256         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED);
257         return (-2);
258     }
259
260     i = b->method->bputs(b, in);
261
262     if (i > 0)
263         b->num_write += (uint64_t)i;
264
265     if (cb != NULL)
266         i = (int)cb(b, BIO_CB_PUTS | BIO_CB_RETURN, in, 0, 0L, (long)i);
267     return (i);
268 }
269
270 int BIO_gets(BIO *b, char *in, int inl)
271 {
272     int i;
273     long (*cb) (BIO *, int, const char *, int, long, long);
274
275     if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) {
276         BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD);
277         return (-2);
278     }
279
280     cb = b->callback;
281
282     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0))
283         return (i);
284
285     if (!b->init) {
286         BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED);
287         return (-2);
288     }
289
290     i = b->method->bgets(b, in, inl);
291
292     if (cb != NULL)
293         i = (int)cb(b, BIO_CB_GETS | BIO_CB_RETURN, in, inl, 0L, (long)i);
294     return (i);
295 }
296
297 int BIO_indent(BIO *b, int indent, int max)
298 {
299     if (indent < 0)
300         indent = 0;
301     if (indent > max)
302         indent = max;
303     while (indent--)
304         if (BIO_puts(b, " ") != 1)
305             return 0;
306     return 1;
307 }
308
309 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
310 {
311     int i;
312
313     i = iarg;
314     return (BIO_ctrl(b, cmd, larg, (char *)&i));
315 }
316
317 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
318 {
319     void *p = NULL;
320
321     if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
322         return (NULL);
323     else
324         return (p);
325 }
326
327 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
328 {
329     long ret;
330     long (*cb) (BIO *, int, const char *, int, long, long);
331
332     if (b == NULL)
333         return (0);
334
335     if ((b->method == NULL) || (b->method->ctrl == NULL)) {
336         BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD);
337         return (-2);
338     }
339
340     cb = b->callback;
341
342     if ((cb != NULL) &&
343         ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0))
344         return (ret);
345
346     ret = b->method->ctrl(b, cmd, larg, parg);
347
348     if (cb != NULL)
349         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, cmd, larg, ret);
350     return (ret);
351 }
352
353 long BIO_callback_ctrl(BIO *b, int cmd,
354                        void (*fp) (struct bio_st *, int, const char *, int,
355                                    long, long))
356 {
357     long ret;
358     long (*cb) (BIO *, int, const char *, int, long, long);
359
360     if (b == NULL)
361         return (0);
362
363     if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) {
364         BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD);
365         return (-2);
366     }
367
368     cb = b->callback;
369
370     if ((cb != NULL) &&
371         ((ret = cb(b, BIO_CB_CTRL, (void *)&fp, cmd, 0, 1L)) <= 0))
372         return (ret);
373
374     ret = b->method->callback_ctrl(b, cmd, fp);
375
376     if (cb != NULL)
377         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, cmd, 0, ret);
378     return (ret);
379 }
380
381 /*
382  * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
383  * do; but those macros have inappropriate return type, and for interfacing
384  * from other programming languages, C macros aren't much of a help anyway.
385  */
386 size_t BIO_ctrl_pending(BIO *bio)
387 {
388     return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
389 }
390
391 size_t BIO_ctrl_wpending(BIO *bio)
392 {
393     return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
394 }
395
396 /* put the 'bio' on the end of b's list of operators */
397 BIO *BIO_push(BIO *b, BIO *bio)
398 {
399     BIO *lb;
400
401     if (b == NULL)
402         return (bio);
403     lb = b;
404     while (lb->next_bio != NULL)
405         lb = lb->next_bio;
406     lb->next_bio = bio;
407     if (bio != NULL)
408         bio->prev_bio = lb;
409     /* called to do internal processing */
410     BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
411     return (b);
412 }
413
414 /* Remove the first and return the rest */
415 BIO *BIO_pop(BIO *b)
416 {
417     BIO *ret;
418
419     if (b == NULL)
420         return (NULL);
421     ret = b->next_bio;
422
423     BIO_ctrl(b, BIO_CTRL_POP, 0, b);
424
425     if (b->prev_bio != NULL)
426         b->prev_bio->next_bio = b->next_bio;
427     if (b->next_bio != NULL)
428         b->next_bio->prev_bio = b->prev_bio;
429
430     b->next_bio = NULL;
431     b->prev_bio = NULL;
432     return (ret);
433 }
434
435 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
436 {
437     BIO *b, *last;
438
439     b = last = bio;
440     for (;;) {
441         if (!BIO_should_retry(b))
442             break;
443         last = b;
444         b = b->next_bio;
445         if (b == NULL)
446             break;
447     }
448     if (reason != NULL)
449         *reason = last->retry_reason;
450     return (last);
451 }
452
453 int BIO_get_retry_reason(BIO *bio)
454 {
455     return (bio->retry_reason);
456 }
457
458 void BIO_set_retry_reason(BIO *bio, int reason)
459 {
460     bio->retry_reason = reason;
461 }
462
463 BIO *BIO_find_type(BIO *bio, int type)
464 {
465     int mt, mask;
466
467     if (bio == NULL)
468         return NULL;
469     mask = type & 0xff;
470     do {
471         if (bio->method != NULL) {
472             mt = bio->method->type;
473
474             if (!mask) {
475                 if (mt & type)
476                     return (bio);
477             } else if (mt == type)
478                 return (bio);
479         }
480         bio = bio->next_bio;
481     } while (bio != NULL);
482     return (NULL);
483 }
484
485 BIO *BIO_next(BIO *b)
486 {
487     if (b == NULL)
488         return NULL;
489     return b->next_bio;
490 }
491
492 void BIO_set_next(BIO *b, BIO *next)
493 {
494     b->next_bio = next;
495 }
496
497 void BIO_free_all(BIO *bio)
498 {
499     BIO *b;
500     int ref;
501
502     while (bio != NULL) {
503         b = bio;
504         ref = b->references;
505         bio = bio->next_bio;
506         BIO_free(b);
507         /* Since ref count > 1, don't free anyone else. */
508         if (ref > 1)
509             break;
510     }
511 }
512
513 BIO *BIO_dup_chain(BIO *in)
514 {
515     BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
516
517     for (bio = in; bio != NULL; bio = bio->next_bio) {
518         if ((new_bio = BIO_new(bio->method)) == NULL)
519             goto err;
520         new_bio->callback = bio->callback;
521         new_bio->cb_arg = bio->cb_arg;
522         new_bio->init = bio->init;
523         new_bio->shutdown = bio->shutdown;
524         new_bio->flags = bio->flags;
525
526         /* This will let SSL_s_sock() work with stdin/stdout */
527         new_bio->num = bio->num;
528
529         if (!BIO_dup_state(bio, (char *)new_bio)) {
530             BIO_free(new_bio);
531             goto err;
532         }
533
534         /* copy app data */
535         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
536                                 &bio->ex_data)) {
537             BIO_free(new_bio);
538             goto err;
539         }
540
541         if (ret == NULL) {
542             eoc = new_bio;
543             ret = eoc;
544         } else {
545             BIO_push(eoc, new_bio);
546             eoc = new_bio;
547         }
548     }
549     return (ret);
550  err:
551     BIO_free_all(ret);
552
553     return (NULL);
554 }
555
556 void BIO_copy_next_retry(BIO *b)
557 {
558     BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
559     b->retry_reason = b->next_bio->retry_reason;
560 }
561
562 int BIO_set_ex_data(BIO *bio, int idx, void *data)
563 {
564     return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data));
565 }
566
567 void *BIO_get_ex_data(BIO *bio, int idx)
568 {
569     return (CRYPTO_get_ex_data(&(bio->ex_data), idx));
570 }
571
572 uint64_t BIO_number_read(BIO *bio)
573 {
574     if (bio)
575         return bio->num_read;
576     return 0;
577 }
578
579 uint64_t BIO_number_written(BIO *bio)
580 {
581     if (bio)
582         return bio->num_write;
583     return 0;
584 }
585
586 void bio_free_ex_data(BIO *bio)
587 {
588     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
589 }
590
591 void bio_cleanup(void)
592 {
593 #ifndef OPENSSL_NO_SOCK
594     bio_sock_cleanup_int();
595     CRYPTO_THREAD_lock_free(bio_lookup_lock);
596     bio_lookup_lock = NULL;
597 #endif
598     CRYPTO_THREAD_lock_free(bio_type_lock);
599     bio_type_lock = NULL;
600 }