Commit c1082a90 authored by Bodo Möller's avatar Bodo Möller
Browse files

Non-copying interface to BIO pairs. 

It's still totally untested ...
parent b7d7440c

CHANGES

+4 −0
Original line number Diff line number Diff line
@@ -4,6 +4,10 @@ 


 Changes between 0.9.4 and 0.9.5  [xx XXX 1999]



  *) Non-copying interface to BIO pairs.

     (still totally untested)

     [Bodo Moeller]



  *) New function ANS1_tag2str() to convert an ASN1 tag to a descriptive

     ASCII string. This was handled independently in various places before.

     [Steve Henson]

crypto/bio/bio.h

+0 −2
Original line number Diff line number Diff line
@@ -517,12 +517,10 @@ BIO * BIO_get_retry_BIO(BIO *bio, int *reason); 
int	BIO_get_retry_reason(BIO *bio);

BIO *	BIO_dup_chain(BIO *in);



#if 0 /* not yet */

int BIO_nread0(BIO *bio, char **buf);

int BIO_nread(BIO *bio, char **buf, int num);

int BIO_nwrite0(BIO *bio, char **buf);

int BIO_nwrite(BIO *bio, char **buf, int num);

#endif



#ifndef WIN16

long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi,

crypto/bio/bss_bio.c

+232 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#endif



#include <assert.h>

#include <limits.h>

#include <stdlib.h>

#include <string.h>
@@ -195,6 +196,82 @@ static int bio_read(BIO *bio, char *buf, int size_) 
	return size;

	}



/* non-copying interface: provide pointer to available data in buffer

 *    bio_nread0:  return number of available bytes

 *    bio_nread:   also advance index

 * (example usage:  bio_nread0(), read from buffer, bio_nread()

 *  or just         bio_nread(), read from buffer)

 */

/* WARNING: The non-copying interface is totally untested as of yet --

 * I wrote it, but have not yet read it; and surely it still is full

 * of bugs. */

static size_t bio_nread0(BIO *bio, char **buf)

	{

	struct bio_bio_st *b, *peer_b;

	size_t num;

	

	BIO_clear_retry_flags(bio);



	if (!bio->init)

		return 0;

	

	b = bio->ptr;

	assert(b != NULL);

	assert(b->peer != NULL);

	peer_b = b->peer->ptr;

	assert(peer_b != NULL);

	assert(peer_b->buf != NULL);

	

	peer_b->request = 0;

	

	if (peer_b->len == 0)

		{

		char dummy;

		

		/* avoid code duplication -- nothing available for reading */

		return bio_read(bio, &dummy, num); /* returns 0 or -1 */

		}



	num = peer_b->len;

	if (peer_b->size < peer_b->offset + num)

		/* no ring buffer wrap-around for non-copying interface */

		num = peer_b->size - peer_b->offset;

	assert(num > 0);



	if (buf != NULL)

		*buf = peer_b->buf + peer_b->offset;

	return num;

	}



static size_t bio_nread(BIO *bio, char **buf, size_t num)

	{

	struct bio_bio_st *b, *peer_b;

	size_t available;



	available = bio_nread0(bio, buf);

	if (num > available)

		num = available;

	if (num <= 0)

		return num;



	b = bio->ptr;

	peer_b = b->peer->ptr;



	peer_b->len -= num;

	if (peer_b->len) 

		{

		peer_b->offset += num;

		assert(peer_b->offset <= peer_b->size);

		if (peer_b->offset == peer_b->size)

			peer_b->offset = 0;

		}

	else

		peer_b->offset = 0;



	return num;

	}





static int bio_write(BIO *bio, char *buf, int num_)

	{

	size_t num = num_;
@@ -268,6 +345,76 @@ static int bio_write(BIO *bio, char *buf, int num_) 
	return num;

	}



/* non-copying interface: provide pointer to region to write to

 *   bio_nwrite0:  check how much space is available

 *   bio_nwrite:   also increase length

 * (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)

	{

	struct bio_bio_st *b;

	size_t num;

	size_t write_offset;



	BIO_clear_retry_flags(bio);



	if (!bio->init)

		return 0;



	b = bio->ptr;		

	assert(b != NULL);

	assert(b->peer != NULL);

	assert(b->buf != NULL);



	b->request = 0;

	if (b->closed)

		{

		BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE);

		return -1;

		}



	assert(b->len <= b->size);



	if (b->len == b->size)

		{

		BIO_set_retry_write(bio);

		return -1;

		}



	num = b->size - b->len;

	write_offset = b->offset + b->len;

	if (write_offset >= b->size)

		write_offset -= b->size;

	if (write_offset + num > b->size)

		/* no ring buffer wrap-around for non-copying interface

		 * (to fulfil the promise by BIO_ctrl_get_write_guarantee,

		 * BIO_nwrite may have to be called twice) */

		num = b->size - write_offset;



	if (buf != NULL)

		*buf = b->buf + write_offset;

	assert(write_offset + num <= b->size);



	return num;

	}



static size_t bio_nwrite(BIO *bio, char **buf, size_t num)

	{

	struct bio_bio_st *b;

	size_t space;



	space = bio_nwrite0(bio, buf);

	if (num > space)

		num = space;

	if (num <= 0)

		return num;

	b->len += num;

	assert(b->len <= b->size);



	return num;

	}





static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)

	{
@@ -351,6 +498,21 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) 
		ret = 1;

		break;



	case BIO_C_NREAD:

		/* non-copying read */

		ret = (long) bio_nread(bio, ptr, (size_t) num);

		break;

		

	case BIO_C_NWRITE0:

		/* prepare for non-copying write */

		ret = (long) bio_nwrite0(bio, ptr);

		break;



	case BIO_C_NWRITE:

		/* non-copying write */

		ret = (long) bio_nwrite(bio, ptr, (size_t) num);

		break;

		



	/* standard CTRL codes follow */
@@ -586,3 +748,73 @@ size_t BIO_ctrl_get_read_request(BIO *bio) 
	{

	return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);

	}





/* BIO_nread0/nread/nwrite0/nwrite are availabe 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)

	{

	long ret;



	if (!bio->init)

		{

		BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED);

		return -2;

		}



	ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf);

	if (ret > INT_MAX)

		return INT_MAX;

	else

		return (int) ret;

	}



int BIO_nread(BIO *bio, char **buf, int num)

	{

	int ret;



	if (!bio->init)

		{

		BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED);

		return -2;

		}



	ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf);

	if (ret > 0)

		bio->num_read += ret;

	return ret;

	}



int BIO_nwrite0(BIO *bio, char **buf)

	{

	long ret;



	if (!bio->init)

		{

		BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED);

		return -2;

		}



	ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf);

	if (ret > INT_MAX)

		return INT_MAX;

	else

		return (int) ret;

	}



int BIO_nwrite(BIO *bio, char **buf, int num)

	{

	int ret;



	if (!bio->init)

		{

		BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED);

		return -2;

		}



	ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf);

	if (ret > 0)

		bio->num_read += ret;

	return ret;

	}

ssl/ssltest.c

+3 −0
Original line number Diff line number Diff line
@@ -653,6 +653,9 @@ int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count) 
			{

			/* "I/O" BETWEEN CLIENT AND SERVER. */



			/* TODO: use non-blocking BIO interface for (say) the client

			 * to illustrate its use and to test it. */



#define RELAYBUFSIZ 200

			static char buf[RELAYBUFSIZ];