Fix various incorrect error function codes.

[openssl.git] / crypto / bio / bio_lib.c

diff --git a/crypto/bio/bio_lib.c b/crypto/bio/bio_lib.c
index ae225da986bcca00f886f96fbf736c6bf7e5a6bc..dcc989f9d6bfb930ec667f87855fcf7bc67006db 100644 (file)
--- a/crypto/bio/bio_lib.c
+++ b/crypto/bio/bio_lib.c
@@ -63,14 +63,11 @@
 #include <openssl/bio.h>
 #include <openssl/stack.h>
 
-static STACK_OF(CRYPTO_EX_DATA_FUNCS) *bio_meth=NULL;
-static int bio_meth_num=0;
-
 BIO *BIO_new(BIO_METHOD *method)
        {
        BIO *ret=NULL;
 
-       ret=(BIO *)Malloc(sizeof(BIO));
+       ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
        if (ret == NULL)
                {
                BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
@@ -78,7 +75,7 @@ BIO *BIO_new(BIO_METHOD *method)
                }
        if (!BIO_set(ret,method))
                {
-               Free(ret);
+               OPENSSL_free(ret);
                ret=NULL;
                }
        return(ret);
@@ -100,10 +97,14 @@ int BIO_set(BIO *bio, BIO_METHOD *method)
        bio->references=1;
        bio->num_read=0L;
        bio->num_write=0L;
-       CRYPTO_new_ex_data(bio_meth,bio,&bio->ex_data);
+       CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
        if (method->create != NULL)
                if (!method->create(bio))
+                       {
+                       CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio,
+                                       &bio->ex_data);
                        return(0);
+                       }
        return(1);
        }
 
@@ -129,18 +130,21 @@ int BIO_free(BIO *a)
                ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0))
                        return(i);
 
-       CRYPTO_free_ex_data(bio_meth,a,&a->ex_data);
+       CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
 
        if ((a->method == NULL) || (a->method->destroy == NULL)) return(1);
        ret=a->method->destroy(a);
-       Free(a);
+       OPENSSL_free(a);
        return(1);
        }
 
+void BIO_vfree(BIO *a)
+    { BIO_free(a); }
+
 int BIO_read(BIO *b, void *out, int outl)
        {
        int i;
-       long (*cb)();
+       long (*cb)(BIO *,int,const char *,int,long,long);
 
        if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL))
                {
@@ -169,10 +173,10 @@ int BIO_read(BIO *b, void *out, int outl)
        return(i);
        }
 
-int BIO_write(BIO *b, const char *in, int inl)
+int BIO_write(BIO *b, const void *in, int inl)
        {
        int i;
-       long (*cb)();
+       long (*cb)(BIO *,int,const char *,int,long,long);
 
        if (b == NULL)
                return(0);
@@ -198,13 +202,7 @@ int BIO_write(BIO *b, const char *in, int inl)
 
        if (i > 0) b->num_write+=(unsigned long)i;
 
-       /* This is evil and not thread safe.  If the BIO has been freed,
-        * we must not call the callback.  The only way to be able to
-        * determine this is the reference count which is now invalid since
-        * the memory has been free()ed.
-        */
-       if (b->references <= 0) abort();
-       if (cb != NULL) /* && (b->references >= 1)) */
+       if (cb != NULL)
                i=(int)cb(b,BIO_CB_WRITE|BIO_CB_RETURN,in,inl,
                        0L,(long)i);
        return(i);
@@ -213,7 +211,7 @@ int BIO_write(BIO *b, const char *in, int inl)
 int BIO_puts(BIO *b, const char *in)
        {
        int i;
-       long (*cb)();
+       long (*cb)(BIO *,int,const char *,int,long,long);
 
        if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL))
                {
@@ -235,6 +233,8 @@ int BIO_puts(BIO *b, const char *in)
 
        i=b->method->bputs(b,in);
 
+       if (i > 0) b->num_write+=(unsigned long)i;
+
        if (cb != NULL)
                i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0,
                        0L,(long)i);
@@ -244,7 +244,7 @@ int BIO_puts(BIO *b, const char *in)
 int BIO_gets(BIO *b, char *in, int inl)
        {
        int i;
-       long (*cb)();
+       long (*cb)(BIO *,int,const char *,int,long,long);
 
        if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL))
                {
@@ -272,6 +272,18 @@ int BIO_gets(BIO *b, char *in, int inl)
        return(i);
        }
 
+int BIO_indent(BIO *b,int indent,int max)
+       {
+       if(indent < 0)
+               indent=0;
+       if(indent > max)
+               indent=max;
+       while(indent--)
+               if(BIO_puts(b," ") != 1)
+                       return 0;
+       return 1;
+       }
+
 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
        {
        int i;
@@ -293,7 +305,7 @@ char *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
        {
        long ret;
-       long (*cb)();
+       long (*cb)(BIO *,int,const char *,int,long,long);
 
        if (b == NULL) return(0);
 
@@ -317,16 +329,43 @@ long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
        return(ret);
        }
 
+long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long))
+       {
+       long ret;
+       long (*cb)(BIO *,int,const char *,int,long,long);
+
+       if (b == NULL) return(0);
+
+       if ((b->method == NULL) || (b->method->callback_ctrl == NULL))
+               {
+               BIOerr(BIO_F_BIO_CALLBACK_CTRL,BIO_R_UNSUPPORTED_METHOD);
+               return(-2);
+               }
+
+       cb=b->callback;
+
+       if ((cb != NULL) &&
+               ((ret=cb(b,BIO_CB_CTRL,(void *)&fp,cmd,0,1L)) <= 0))
+               return(ret);
+
+       ret=b->method->callback_ctrl(b,cmd,fp);
+
+       if (cb != NULL)
+               ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp,cmd,
+                       0,ret);
+       return(ret);
+       }
+
 /* It is unfortunate to duplicate in functions what the BIO_(w)pending macros
  * do; but those macros have inappropriate return type, and for interfacing
  * from other programming languages, C macros aren't much of a help anyway. */
 size_t BIO_ctrl_pending(BIO *bio)
-    {
+       {
        return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
        }
 
 size_t BIO_ctrl_wpending(BIO *bio)
-    {
+       {
        return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
        }
 
@@ -356,6 +395,8 @@ BIO *BIO_pop(BIO *b)
        if (b == NULL) return(NULL);
        ret=b->next_bio;
 
+       BIO_ctrl(b,BIO_CTRL_POP,0,NULL);
+
        if (b->prev_bio != NULL)
                b->prev_bio->next_bio=b->next_bio;
        if (b->next_bio != NULL)
@@ -363,7 +404,6 @@ BIO *BIO_pop(BIO *b)
 
        b->next_bio=NULL;
        b->prev_bio=NULL;
-       BIO_ctrl(b,BIO_CTRL_POP,0,NULL);
        return(ret);
        }
 
@@ -392,6 +432,7 @@ BIO *BIO_find_type(BIO *bio, int type)
        {
        int mt,mask;
 
+       if(!bio) return NULL;
        mask=type&0xff;
        do      {
                if (bio->method != NULL)
@@ -410,6 +451,12 @@ BIO *BIO_find_type(BIO *bio, int type)
        return(NULL);
        }
 
+BIO *BIO_next(BIO *b)
+       {
+       if(!b) return NULL;
+       return b->next_bio;
+       }
+
 void BIO_free_all(BIO *bio)
        {
        BIO *b;
@@ -449,7 +496,8 @@ BIO *BIO_dup_chain(BIO *in)
                        }
 
                /* copy app data */
-               if (!CRYPTO_dup_ex_data(bio_meth,&new->ex_data,&bio->ex_data))
+               if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new->ex_data,
+                                       &bio->ex_data))
                        goto err;
 
                if (ret == NULL)
@@ -479,9 +527,8 @@ void BIO_copy_next_retry(BIO *b)
 int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
        {
-       bio_meth_num++;
-       return(CRYPTO_get_ex_new_index(bio_meth_num-1,&bio_meth,
-               argl,argp,new_func,dup_func,free_func));
+       return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp,
+                               new_func, dup_func, free_func);
        }
 
 int BIO_set_ex_data(BIO *bio, int idx, void *data)
@@ -505,3 +552,5 @@ unsigned long BIO_number_written(BIO *bio)
        if(bio) return bio->num_write;
        return 0;
 }
+
+IMPLEMENT_STACK_OF(BIO)