{
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);
}
if (!BIO_set(ret,method))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
return(ret);
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;
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)();
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);
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);
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)();
+
+ if (b == NULL) return(0);
+
+ if ((b->method == NULL) || (b->method->callback_ctrl == NULL))
+ {
+ BIOerr(BIO_F_BIO_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);
}
if(bio) return bio->num_write;
return 0;
}
+
+IMPLEMENT_STACK_OF(BIO)