Move to REF_DEBUG, for consistency.
[openssl.git] / crypto / bio / bio_lib.c
1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
4  * This package is an SSL implementation written
5  * by Eric Young (eay@cryptsoft.com).
6  * The implementation was written so as to conform with Netscapes SSL.
7  *
8  * This library is free for commercial and non-commercial use as long as
9  * the following conditions are aheared to.  The following conditions
10  * apply to all code found in this distribution, be it the RC4, RSA,
11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12  * included with this distribution is covered by the same copyright terms
13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14  *
15  * Copyright remains Eric Young's, and as such any Copyright notices in
16  * the code are not to be removed.
17  * If this package is used in a product, Eric Young should be given attribution
18  * as the author of the parts of the library used.
19  * This can be in the form of a textual message at program startup or
20  * in documentation (online or textual) provided with the package.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  * 1. Redistributions of source code must retain the copyright
26  *    notice, this list of conditions and the following disclaimer.
27  * 2. Redistributions in binary form must reproduce the above copyright
28  *    notice, this list of conditions and the following disclaimer in the
29  *    documentation and/or other materials provided with the distribution.
30  * 3. All advertising materials mentioning features or use of this software
31  *    must display the following acknowledgement:
32  *    "This product includes cryptographic software written by
33  *     Eric Young (eay@cryptsoft.com)"
34  *    The word 'cryptographic' can be left out if the rouines from the library
35  *    being used are not cryptographic related :-).
36  * 4. If you include any Windows specific code (or a derivative thereof) from
37  *    the apps directory (application code) you must include an acknowledgement:
38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  *
52  * The licence and distribution terms for any publically available version or
53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
54  * copied and put under another distribution licence
55  * [including the GNU Public Licence.]
56  */
57
58 #include <stdio.h>
59 #include <errno.h>
60 #include <openssl/crypto.h>
61 #include "internal/cryptlib.h"
62 #include <openssl/bio.h>
63 #include <openssl/stack.h>
64
65 BIO *BIO_new(BIO_METHOD *method)
66 {
67     BIO *ret = OPENSSL_malloc(sizeof(*ret));
68
69     if (ret == NULL) {
70         BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
71         return (NULL);
72     }
73     if (!BIO_set(ret, method)) {
74         OPENSSL_free(ret);
75         ret = NULL;
76     }
77     return (ret);
78 }
79
80 int BIO_set(BIO *bio, BIO_METHOD *method)
81 {
82     bio->method = method;
83     bio->callback = NULL;
84     bio->cb_arg = NULL;
85     bio->init = 0;
86     bio->shutdown = 1;
87     bio->flags = 0;
88     bio->retry_reason = 0;
89     bio->num = 0;
90     bio->ptr = NULL;
91     bio->prev_bio = NULL;
92     bio->next_bio = NULL;
93     bio->references = 1;
94     bio->num_read = 0L;
95     bio->num_write = 0L;
96     CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
97     if (method->create != NULL)
98         if (!method->create(bio)) {
99             CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
100             return (0);
101         }
102     return (1);
103 }
104
105 int BIO_free(BIO *a)
106 {
107     int i;
108
109     if (a == NULL)
110         return (0);
111
112     i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_BIO);
113     REF_PRINT_COUNT("BIO", a);
114     if (i > 0)
115         return (1);
116     REF_ASSERT_ISNT(i < 0);
117     if ((a->callback != NULL) &&
118         ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
119         return (i);
120
121     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
122
123     if ((a->method != NULL) && (a->method->destroy != NULL))
124         a->method->destroy(a);
125     OPENSSL_free(a);
126     return (1);
127 }
128
129 void BIO_vfree(BIO *a)
130 {
131     BIO_free(a);
132 }
133
134 void BIO_clear_flags(BIO *b, int flags)
135 {
136     b->flags &= ~flags;
137 }
138
139 int BIO_test_flags(const BIO *b, int flags)
140 {
141     return (b->flags & flags);
142 }
143
144 void BIO_set_flags(BIO *b, int flags)
145 {
146     b->flags |= flags;
147 }
148
149 long (*BIO_get_callback(const BIO *b)) (struct bio_st *, int, const char *,
150                                         int, long, long) {
151     return b->callback;
152 }
153
154 void BIO_set_callback(BIO *b,
155                       long (*cb) (struct bio_st *, int, const char *, int,
156                                   long, long))
157 {
158     b->callback = cb;
159 }
160
161 void BIO_set_callback_arg(BIO *b, char *arg)
162 {
163     b->cb_arg = arg;
164 }
165
166 char *BIO_get_callback_arg(const BIO *b)
167 {
168     return b->cb_arg;
169 }
170
171 const char *BIO_method_name(const BIO *b)
172 {
173     return b->method->name;
174 }
175
176 int BIO_method_type(const BIO *b)
177 {
178     return b->method->type;
179 }
180
181 int BIO_read(BIO *b, void *out, int outl)
182 {
183     int i;
184     long (*cb) (BIO *, int, const char *, int, long, long);
185
186     if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
187         BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
188         return (-2);
189     }
190
191     cb = b->callback;
192     if ((cb != NULL) &&
193         ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0))
194         return (i);
195
196     if (!b->init) {
197         BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
198         return (-2);
199     }
200
201     i = b->method->bread(b, out, outl);
202
203     if (i > 0)
204         b->num_read += (uint64_t)i;
205
206     if (cb != NULL)
207         i = (int)cb(b, BIO_CB_READ | BIO_CB_RETURN, out, outl, 0L, (long)i);
208     return (i);
209 }
210
211 int BIO_write(BIO *b, const void *in, int inl)
212 {
213     int i;
214     long (*cb) (BIO *, int, const char *, int, long, long);
215
216     if (b == NULL)
217         return (0);
218
219     cb = b->callback;
220     if ((b->method == NULL) || (b->method->bwrite == NULL)) {
221         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNSUPPORTED_METHOD);
222         return (-2);
223     }
224
225     if ((cb != NULL) &&
226         ((i = (int)cb(b, BIO_CB_WRITE, in, inl, 0L, 1L)) <= 0))
227         return (i);
228
229     if (!b->init) {
230         BIOerr(BIO_F_BIO_WRITE, BIO_R_UNINITIALIZED);
231         return (-2);
232     }
233
234     i = b->method->bwrite(b, in, inl);
235
236     if (i > 0)
237         b->num_write += (uint64_t)i;
238
239     if (cb != NULL)
240         i = (int)cb(b, BIO_CB_WRITE | BIO_CB_RETURN, in, inl, 0L, (long)i);
241     return (i);
242 }
243
244 int BIO_puts(BIO *b, const char *in)
245 {
246     int i;
247     long (*cb) (BIO *, int, const char *, int, long, long);
248
249     if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) {
250         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD);
251         return (-2);
252     }
253
254     cb = b->callback;
255
256     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0))
257         return (i);
258
259     if (!b->init) {
260         BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED);
261         return (-2);
262     }
263
264     i = b->method->bputs(b, in);
265
266     if (i > 0)
267         b->num_write += (uint64_t)i;
268
269     if (cb != NULL)
270         i = (int)cb(b, BIO_CB_PUTS | BIO_CB_RETURN, in, 0, 0L, (long)i);
271     return (i);
272 }
273
274 int BIO_gets(BIO *b, char *in, int inl)
275 {
276     int i;
277     long (*cb) (BIO *, int, const char *, int, long, long);
278
279     if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) {
280         BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD);
281         return (-2);
282     }
283
284     cb = b->callback;
285
286     if ((cb != NULL) && ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0))
287         return (i);
288
289     if (!b->init) {
290         BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED);
291         return (-2);
292     }
293
294     i = b->method->bgets(b, in, inl);
295
296     if (cb != NULL)
297         i = (int)cb(b, BIO_CB_GETS | BIO_CB_RETURN, in, inl, 0L, (long)i);
298     return (i);
299 }
300
301 int BIO_indent(BIO *b, int indent, int max)
302 {
303     if (indent < 0)
304         indent = 0;
305     if (indent > max)
306         indent = max;
307     while (indent--)
308         if (BIO_puts(b, " ") != 1)
309             return 0;
310     return 1;
311 }
312
313 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
314 {
315     int i;
316
317     i = iarg;
318     return (BIO_ctrl(b, cmd, larg, (char *)&i));
319 }
320
321 void *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
322 {
323     void *p = NULL;
324
325     if (BIO_ctrl(b, cmd, larg, (char *)&p) <= 0)
326         return (NULL);
327     else
328         return (p);
329 }
330
331 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
332 {
333     long ret;
334     long (*cb) (BIO *, int, const char *, int, long, long);
335
336     if (b == NULL)
337         return (0);
338
339     if ((b->method == NULL) || (b->method->ctrl == NULL)) {
340         BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD);
341         return (-2);
342     }
343
344     cb = b->callback;
345
346     if ((cb != NULL) &&
347         ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0))
348         return (ret);
349
350     ret = b->method->ctrl(b, cmd, larg, parg);
351
352     if (cb != NULL)
353         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, parg, cmd, larg, ret);
354     return (ret);
355 }
356
357 long BIO_callback_ctrl(BIO *b, int cmd,
358                        void (*fp) (struct bio_st *, int, const char *, int,
359                                    long, long))
360 {
361     long ret;
362     long (*cb) (BIO *, int, const char *, int, long, long);
363
364     if (b == NULL)
365         return (0);
366
367     if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) {
368         BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD);
369         return (-2);
370     }
371
372     cb = b->callback;
373
374     if ((cb != NULL) &&
375         ((ret = cb(b, BIO_CB_CTRL, (void *)&fp, cmd, 0, 1L)) <= 0))
376         return (ret);
377
378     ret = b->method->callback_ctrl(b, cmd, fp);
379
380     if (cb != NULL)
381         ret = cb(b, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, cmd, 0, ret);
382     return (ret);
383 }
384
385 /*
386  * It is unfortunate to duplicate in functions what the BIO_(w)pending macros
387  * do; but those macros have inappropriate return type, and for interfacing
388  * from other programming languages, C macros aren't much of a help anyway.
389  */
390 size_t BIO_ctrl_pending(BIO *bio)
391 {
392     return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
393 }
394
395 size_t BIO_ctrl_wpending(BIO *bio)
396 {
397     return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
398 }
399
400 /* put the 'bio' on the end of b's list of operators */
401 BIO *BIO_push(BIO *b, BIO *bio)
402 {
403     BIO *lb;
404
405     if (b == NULL)
406         return (bio);
407     lb = b;
408     while (lb->next_bio != NULL)
409         lb = lb->next_bio;
410     lb->next_bio = bio;
411     if (bio != NULL)
412         bio->prev_bio = lb;
413     /* called to do internal processing */
414     BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
415     return (b);
416 }
417
418 /* Remove the first and return the rest */
419 BIO *BIO_pop(BIO *b)
420 {
421     BIO *ret;
422
423     if (b == NULL)
424         return (NULL);
425     ret = b->next_bio;
426
427     BIO_ctrl(b, BIO_CTRL_POP, 0, b);
428
429     if (b->prev_bio != NULL)
430         b->prev_bio->next_bio = b->next_bio;
431     if (b->next_bio != NULL)
432         b->next_bio->prev_bio = b->prev_bio;
433
434     b->next_bio = NULL;
435     b->prev_bio = NULL;
436     return (ret);
437 }
438
439 BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
440 {
441     BIO *b, *last;
442
443     b = last = bio;
444     for (;;) {
445         if (!BIO_should_retry(b))
446             break;
447         last = b;
448         b = b->next_bio;
449         if (b == NULL)
450             break;
451     }
452     if (reason != NULL)
453         *reason = last->retry_reason;
454     return (last);
455 }
456
457 int BIO_get_retry_reason(BIO *bio)
458 {
459     return (bio->retry_reason);
460 }
461
462 BIO *BIO_find_type(BIO *bio, int type)
463 {
464     int mt, mask;
465
466     if (bio == NULL)
467         return NULL;
468     mask = type & 0xff;
469     do {
470         if (bio->method != NULL) {
471             mt = bio->method->type;
472
473             if (!mask) {
474                 if (mt & type)
475                     return (bio);
476             } else if (mt == type)
477                 return (bio);
478         }
479         bio = bio->next_bio;
480     } while (bio != NULL);
481     return (NULL);
482 }
483
484 BIO *BIO_next(BIO *b)
485 {
486     if (b == NULL)
487         return NULL;
488     return b->next_bio;
489 }
490
491 void BIO_free_all(BIO *bio)
492 {
493     BIO *b;
494     int ref;
495
496     while (bio != NULL) {
497         b = bio;
498         ref = b->references;
499         bio = bio->next_bio;
500         BIO_free(b);
501         /* Since ref count > 1, don't free anyone else. */
502         if (ref > 1)
503             break;
504     }
505 }
506
507 BIO *BIO_dup_chain(BIO *in)
508 {
509     BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
510
511     for (bio = in; bio != NULL; bio = bio->next_bio) {
512         if ((new_bio = BIO_new(bio->method)) == NULL)
513             goto err;
514         new_bio->callback = bio->callback;
515         new_bio->cb_arg = bio->cb_arg;
516         new_bio->init = bio->init;
517         new_bio->shutdown = bio->shutdown;
518         new_bio->flags = bio->flags;
519
520         /* This will let SSL_s_sock() work with stdin/stdout */
521         new_bio->num = bio->num;
522
523         if (!BIO_dup_state(bio, (char *)new_bio)) {
524             BIO_free(new_bio);
525             goto err;
526         }
527
528         /* copy app data */
529         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data,
530                                 &bio->ex_data)) {
531             BIO_free(new_bio);
532             goto err;
533         }
534
535         if (ret == NULL) {
536             eoc = new_bio;
537             ret = eoc;
538         } else {
539             BIO_push(eoc, new_bio);
540             eoc = new_bio;
541         }
542     }
543     return (ret);
544  err:
545     BIO_free_all(ret);
546
547     return (NULL);
548 }
549
550 void BIO_copy_next_retry(BIO *b)
551 {
552     BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
553     b->retry_reason = b->next_bio->retry_reason;
554 }
555
556 int BIO_set_ex_data(BIO *bio, int idx, void *data)
557 {
558     return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data));
559 }
560
561 void *BIO_get_ex_data(BIO *bio, int idx)
562 {
563     return (CRYPTO_get_ex_data(&(bio->ex_data), idx));
564 }
565
566 uint64_t BIO_number_read(BIO *bio)
567 {
568     if (bio)
569         return bio->num_read;
570     return 0;
571 }
572
573 uint64_t BIO_number_written(BIO *bio)
574 {
575     if (bio)
576         return bio->num_write;
577     return 0;
578 }