1 /* crypto/bio/bss_mem.c */

     2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

     3  * All rights reserved.

     4  *

     5  * This package is an SSL implementation written

     6  * by Eric Young (eay@cryptsoft.com).

     7  * The implementation was written so as to conform with Netscapes SSL.

     8  * 

     9  * This library is free for commercial and non-commercial use as long as

    10  * the following conditions are aheared to.  The following conditions

    11  * apply to all code found in this distribution, be it the RC4, RSA,

    12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

    13  * included with this distribution is covered by the same copyright terms

    14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

    15  * 

    16  * Copyright remains Eric Young's, and as such any Copyright notices in

    17  * the code are not to be removed.

    18  * If this package is used in a product, Eric Young should be given attribution

    19  * as the author of the parts of the library used.

    20  * This can be in the form of a textual message at program startup or

    21  * in documentation (online or textual) provided with the package.

    22  * 

    23  * Redistribution and use in source and binary forms, with or without

    24  * modification, are permitted provided that the following conditions

    25  * are met:

    26  * 1. Redistributions of source code must retain the copyright

    27  *    notice, this list of conditions and the following disclaimer.

    28  * 2. Redistributions in binary form must reproduce the above copyright

    29  *    notice, this list of conditions and the following disclaimer in the

    30  *    documentation and/or other materials provided with the distribution.

    31  * 3. All advertising materials mentioning features or use of this software

    32  *    must display the following acknowledgement:

    33  *    "This product includes cryptographic software written by

    34  *     Eric Young (eay@cryptsoft.com)"

    35  *    The word 'cryptographic' can be left out if the rouines from the library

    36  *    being used are not cryptographic related :-).

    37  * 4. If you include any Windows specific code (or a derivative thereof) from 

    38  *    the apps directory (application code) you must include an acknowledgement:

    39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

    40  * 

    41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

    42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

    45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    51  * SUCH DAMAGE.

    52  * 

    53  * The licence and distribution terms for any publically available version or

    54  * derivative of this code cannot be changed.  i.e. this code cannot simply be

    55  * copied and put under another distribution licence

    56  * [including the GNU Public Licence.]

    57  */

    58 /*

    59  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

    60  */

    61 

    62 

    63 #include <stdio.h>

    64 #include <errno.h>

    65 #include "cryptlib.h"

    66 #include <openssl/bio.h>

    67 #if (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__)))

    68 #include "libcrypto_wsd_macros.h"

    69 #include "libcrypto_wsd.h"

    70 #endif

    71 

    72 static int mem_write(BIO *h, const char *buf, int num);

    73 static int mem_read(BIO *h, char *buf, int size);

    74 static int mem_puts(BIO *h, const char *str);

    75 static int mem_gets(BIO *h, char *str, int size);

    76 static long mem_ctrl(BIO *h, int cmd, long arg1, void *arg2);

    77 static int mem_new(BIO *h);

    78 static int mem_free(BIO *data);

    79 #ifndef EMULATOR

    80 static BIO_METHOD mem_method=

    81 	{

    82 	BIO_TYPE_MEM,

    83 	"memory buffer",

    84 	mem_write,

    85 	mem_read,

    86 	mem_puts,

    87 	mem_gets,

    88 	mem_ctrl,

    89 	mem_new,

    90 	mem_free,

    91 	NULL,

    92 	};

    93 #else

    94 GET_STATIC_VAR_FROM_TLS(mem_method,bss_mem,BIO_METHOD)

    95 #define mem_method (*GET_WSD_VAR_NAME(mem_method,bss_mem,s)())

    96 const BIO_METHOD temp_s_mem_method=

    97 	{

    98 	BIO_TYPE_MEM,

    99 	"memory buffer",

   100 	mem_write,

   101 	mem_read,

   102 	mem_puts,

   103 	mem_gets,

   104 	mem_ctrl,

   105 	mem_new,

   106 	mem_free,

   107 	NULL,

   108 	};

   109   

   110 

   111 #endif

   112 /* bio->num is used to hold the value to return on 'empty', if it is

   113  * 0, should_retry is not set */

   114 

   115 EXPORT_C BIO_METHOD *BIO_s_mem(void)

   116 	{

   117 	return(&mem_method);

   118 	}

   119 

   120 EXPORT_C BIO *BIO_new_mem_buf(void *buf, int len)

   121 {

   122 	BIO *ret;

   123 	BUF_MEM *b;

   124 	if (!buf) {

   125 		BIOerr(BIO_F_BIO_NEW_MEM_BUF,BIO_R_NULL_PARAMETER);

   126 		return NULL;

   127 	}

   128 	if(len == -1) len = strlen(buf);

   129 	if(!(ret = BIO_new(BIO_s_mem())) ) return NULL;

   130 	b = (BUF_MEM *)ret->ptr;

   131 	b->data = buf;

   132 	b->length = len;

   133 	b->max = len;

   134 	ret->flags |= BIO_FLAGS_MEM_RDONLY;

   135 	/* Since this is static data retrying wont help */

   136 	ret->num = 0;

   137 	return ret;

   138 }

   139 

   140 static int mem_new(BIO *bi)

   141 	{

   142 	BUF_MEM *b;

   143 

   144 	if ((b=BUF_MEM_new()) == NULL)

   145 		return(0);

   146 	bi->shutdown=1;

   147 	bi->init=1;

   148 	bi->num= -1;

   149 	bi->ptr=(char *)b;

   150 	return(1);

   151 	}

   152 

   153 static int mem_free(BIO *a)

   154 	{

   155 	if (a == NULL) return(0);

   156 	if (a->shutdown)

   157 		{

   158 		if ((a->init) && (a->ptr != NULL))

   159 			{

   160 			BUF_MEM *b;

   161 			b = (BUF_MEM *)a->ptr;

   162 			if(a->flags & BIO_FLAGS_MEM_RDONLY) b->data = NULL;

   163 			BUF_MEM_free(b);

   164 			a->ptr=NULL;

   165 			}

   166 		}

   167 	return(1);

   168 	}

   169 	

   170 static int mem_read(BIO *b, char *out, int outl)

   171 	{

   172 	int ret= -1;

   173 	BUF_MEM *bm;

   174 	int i;

   175 	char *from,*to;

   176 

   177 	bm=(BUF_MEM *)b->ptr;

   178 	BIO_clear_retry_flags(b);

   179 	ret=(outl > bm->length)?bm->length:outl;

   180 	if ((out != NULL) && (ret > 0)) {

   181 		memcpy(out,bm->data,ret);

   182 		bm->length-=ret;

   183 		/* memmove(&(bm->data[0]),&(bm->data[ret]), bm->length); */

   184 		if(b->flags & BIO_FLAGS_MEM_RDONLY) bm->data += ret;

   185 		else {

   186 			from=(char *)&(bm->data[ret]);

   187 			to=(char *)&(bm->data[0]);

   188 			for (i=0; i<bm->length; i++)

   189 				to[i]=from[i];

   190 		}

   191 	} else if (bm->length == 0)

   192 		{

   193 		ret = b->num;

   194 		if (ret != 0)

   195 			BIO_set_retry_read(b);

   196 		}

   197 	return(ret);

   198 	}

   199 

   200 static int mem_write(BIO *b, const char *in, int inl)

   201 	{

   202 	int ret= -1;

   203 	int blen;

   204 	BUF_MEM *bm;

   205 

   206 	bm=(BUF_MEM *)b->ptr;

   207 	if (in == NULL)

   208 		{

   209 		BIOerr(BIO_F_MEM_WRITE,BIO_R_NULL_PARAMETER);

   210 		goto end;

   211 		}

   212 

   213 	if(b->flags & BIO_FLAGS_MEM_RDONLY) {

   214 		BIOerr(BIO_F_MEM_WRITE,BIO_R_WRITE_TO_READ_ONLY_BIO);

   215 		goto end;

   216 	}

   217 

   218 	BIO_clear_retry_flags(b);

   219 	blen=bm->length;

   220 	if (BUF_MEM_grow_clean(bm,blen+inl) != (blen+inl))

   221 		goto end;

   222 	memcpy(&(bm->data[blen]),in,inl);

   223 	ret=inl;

   224 end:

   225 	return(ret);

   226 	}

   227 

   228 static long mem_ctrl(BIO *b, int cmd, long num, void *ptr)

   229 	{

   230 	long ret=1;

   231 	char **pptr;

   232 

   233 	BUF_MEM *bm=(BUF_MEM *)b->ptr;

   234 

   235 	switch (cmd)

   236 		{

   237 	case BIO_CTRL_RESET:

   238 		if (bm->data != NULL)

   239 			{

   240 			/* For read only case reset to the start again */

   241 			if(b->flags & BIO_FLAGS_MEM_RDONLY) 

   242 				{

   243 				bm->data -= bm->max - bm->length;

   244 				bm->length = bm->max;

   245 				}

   246 			else

   247 				{

   248 				memset(bm->data,0,bm->max);

   249 				bm->length=0;

   250 				}

   251 			}

   252 		break;

   253 	case BIO_CTRL_EOF:

   254 		ret=(long)(bm->length == 0);

   255 		break;

   256 	case BIO_C_SET_BUF_MEM_EOF_RETURN:

   257 		b->num=(int)num;

   258 		break;

   259 	case BIO_CTRL_INFO:

   260 		ret=(long)bm->length;

   261 		if (ptr != NULL)

   262 			{

   263 			pptr=(char **)ptr;

   264 			*pptr=(char *)&(bm->data[0]);

   265 			}

   266 		break;

   267 	case BIO_C_SET_BUF_MEM:

   268 		mem_free(b);

   269 		b->shutdown=(int)num;

   270 		b->ptr=ptr;

   271 		break;

   272 	case BIO_C_GET_BUF_MEM_PTR:

   273 		if (ptr != NULL)

   274 			{

   275 			pptr=(char **)ptr;

   276 			*pptr=(char *)bm;

   277 			}

   278 		break;

   279 	case BIO_CTRL_GET_CLOSE:

   280 		ret=(long)b->shutdown;

   281 		break;

   282 	case BIO_CTRL_SET_CLOSE:

   283 		b->shutdown=(int)num;

   284 		break;

   285 

   286 	case BIO_CTRL_WPENDING:

   287 		ret=0L;

   288 		break;

   289 	case BIO_CTRL_PENDING:

   290 		ret=(long)bm->length;

   291 		break;

   292 	case BIO_CTRL_DUP:

   293 	case BIO_CTRL_FLUSH:

   294 		ret=1;

   295 		break;

   296 	case BIO_CTRL_PUSH:

   297 	case BIO_CTRL_POP:

   298 	default:

   299 		ret=0;

   300 		break;

   301 		}

   302 	return(ret);

   303 	}

   304 

   305 static int mem_gets(BIO *bp, char *buf, int size)

   306 	{

   307 	int i,j;

   308 	int ret= -1;

   309 	char *p;

   310 	BUF_MEM *bm=(BUF_MEM *)bp->ptr;

   311 

   312 	BIO_clear_retry_flags(bp);

   313 	j=bm->length;

   314 	if (j <= 0)

   315 		{

   316 		*buf='\0';

   317 		return 0;

   318 		}

   319 	p=bm->data;

   320 	for (i=0; i<j; i++)

   321 		{

   322 		if (p[i] == '\n') break;

   323 		}

   324 	if (i == j)

   325 		{

   326 		BIO_set_retry_read(bp);

   327 		/* return(-1);  change the semantics 0.6.6a */ 

   328 		}

   329 	else

   330 		i++;

   331 	/* i is the max to copy */

   332 	if ((size-1) < i) i=size-1;

   333 	i=mem_read(bp,buf,i);

   334 	if (i > 0) buf[i]='\0';

   335 	ret=i;

   336 	return(ret);

   337 	}

   338 

   339 static int mem_puts(BIO *bp, const char *str)

   340 	{

   341 	int n,ret;

   342 

   343 	n=strlen(str);

   344 	ret=mem_write(bp,str,n);

   345 	/* memory semantics is that it will always work */

   346 	return(ret);

   347 	}

   348