#include <openssl/bio.h>
#include <openssl/err.h>
+#include <openssl/err.h>
#include <openssl/crypto.h>
+#include "openssl/e_os.h"
+#ifndef SSIZE_MAX
+# define SSIZE_MAX INT_MAX
+#endif
+
static int bio_new(BIO *bio);
static int bio_free(BIO *bio);
static int bio_read(BIO *bio, char *buf, int size);
-static int bio_write(BIO *bio, char *buf, int num);
+static int bio_write(BIO *bio, const char *buf, int num);
static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr);
-static int bio_puts(BIO *bio, char *str);
+static int bio_puts(BIO *bio, const char *str);
static int bio_make_pair(BIO *bio1, BIO *bio2);
static void bio_destroy_pair(BIO *bio);
NULL /* no bio_gets */,
bio_ctrl,
bio_new,
- bio_free
+ bio_free,
+ NULL /* no bio_callback_ctrl */
};
BIO_METHOD *BIO_s_bio(void)
size_t request; /* valid iff peer != NULL; 0 if len != 0,
* otherwise set by peer to number of bytes
- * it (unsuccesfully) tried to read,
+ * it (unsuccessfully) tried to read,
* never more than buffer space (size-len) warrants. */
};
{
struct bio_bio_st *b;
- b = Malloc(sizeof *b);
+ b = OPENSSL_malloc(sizeof *b);
if (b == NULL)
return 0;
if (b->buf != NULL)
{
- Free(b->buf);
+ OPENSSL_free(b->buf);
}
- Free(b);
+ OPENSSL_free(b);
return 1;
}
*/
/* WARNING: The non-copying interface is largely untested as of yet
* and may contain bugs. */
-static size_t bio_nread0(BIO *bio, char **buf)
+static ssize_t bio_nread0(BIO *bio, char **buf)
{
struct bio_bio_st *b, *peer_b;
- size_t num;
+ ssize_t num;
BIO_clear_retry_flags(bio);
return num;
}
-static size_t bio_nread(BIO *bio, char **buf, size_t num)
+static ssize_t bio_nread(BIO *bio, char **buf, size_t num_)
{
struct bio_bio_st *b, *peer_b;
- size_t available;
+ ssize_t num, available;
+
+ if (num_ > SSIZE_MAX)
+ num = SSIZE_MAX;
+ else
+ num = (ssize_t)num_;
available = bio_nread0(bio, buf);
if (num > available)
}
-static int bio_write(BIO *bio, char *buf, int num_)
+static int bio_write(BIO *bio, const char *buf, int num_)
{
size_t num = num_;
size_t rest;
* (example usage: bio_nwrite0(), write to buffer, bio_nwrite()
* or just bio_nwrite(), write to buffer)
*/
-static size_t bio_nwrite0(BIO *bio, char **buf)
+static ssize_t bio_nwrite0(BIO *bio, char **buf)
{
struct bio_bio_st *b;
size_t num;
return num;
}
-static size_t bio_nwrite(BIO *bio, char **buf, size_t num)
+static ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_)
{
- struct bio_bio_st *b=bio->ptr;
- size_t space;
+ struct bio_bio_st *b;
+ ssize_t num, space;
+
+ if (num_ > SSIZE_MAX)
+ num = SSIZE_MAX;
+ else
+ num = (ssize_t)num_;
space = bio_nwrite0(bio, buf);
if (num > space)
num = space;
if (num <= 0)
return num;
+ b = bio->ptr;
+ assert(b != NULL);
b->len += num;
assert(b->len <= b->size);
{
if (b->buf)
{
- Free(b->buf);
+ OPENSSL_free(b->buf);
b->buf = NULL;
}
b->size = new_size;
case BIO_C_GET_WRITE_GUARANTEE:
/* How many bytes can the caller feed to the next write
- * withouth having to keep any? */
+ * without having to keep any? */
if (b->peer == NULL || b->closed)
ret = 0;
else
break;
case BIO_C_GET_READ_REQUEST:
- /* If the peer unsuccesfully tried to read, how many bytes
+ /* If the peer unsuccessfully tried to read, how many bytes
* were requested? (As with BIO_CTRL_PENDING, that number
* can usually be treated as boolean.) */
ret = (long) b->request;
break;
+ case BIO_C_RESET_READ_REQUEST:
+ /* Reset request. (Can be useful after read attempts
+ * at the other side that are meant to be non-blocking,
+ * e.g. when probing SSL_read to see if any data is
+ * available.) */
+ b->request = 0;
+ ret = 1;
+ break;
+
case BIO_C_SHUTDOWN_WR:
/* similar to shutdown(..., SHUT_WR) */
b->closed = 1;
ret = 1;
break;
+ case BIO_C_NREAD0:
+ /* prepare for non-copying read */
+ ret = (long) bio_nread0(bio, ptr);
+ break;
+
case BIO_C_NREAD:
/* non-copying read */
ret = (long) bio_nread(bio, ptr, (size_t) num);
return ret;
}
-static int bio_puts(BIO *bio, char *str)
+static int bio_puts(BIO *bio, const char *str)
{
return bio_write(bio, str, strlen(str));
}
if (b1->buf == NULL)
{
- b1->buf = Malloc(b1->size);
+ b1->buf = OPENSSL_malloc(b1->size);
if (b1->buf == NULL)
{
BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
if (b2->buf == NULL)
{
- b2->buf = Malloc(b2->size);
+ b2->buf = OPENSSL_malloc(b2->size);
if (b2->buf == NULL)
{
BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
}
+int BIO_ctrl_reset_read_request(BIO *bio)
+ {
+ return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0);
+ }
+
-/* BIO_nread0/nread/nwrite0/nwrite are availabe only for BIO pairs for now
+/* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now
* (conceivably some other BIOs could allow non-copying reads and writes too.)
*/
int BIO_nread0(BIO *bio, char **buf)