b_sock.c: fix compiler warning.
[openssl.git] / crypto / bio / bf_lbuf.c
1 /* crypto/bio/bf_buff.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 #include <stdio.h>
60 #include <errno.h>
61 #include "cryptlib.h"
62 #include <openssl/bio.h>
63 #include <openssl/evp.h>
64
65 static int linebuffer_write(BIO *h, const char *buf,int num);
66 static int linebuffer_read(BIO *h, char *buf, int size);
67 static int linebuffer_puts(BIO *h, const char *str);
68 static int linebuffer_gets(BIO *h, char *str, int size);
69 static long linebuffer_ctrl(BIO *h, int cmd, long arg1, void *arg2);
70 static int linebuffer_new(BIO *h);
71 static int linebuffer_free(BIO *data);
72 static long linebuffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
73
74 /* A 10k maximum should be enough for most purposes */
75 #define DEFAULT_LINEBUFFER_SIZE 1024*10
76
77 /* #define DEBUG */
78
79 static BIO_METHOD methods_linebuffer=
80         {
81         BIO_TYPE_LINEBUFFER,
82         "linebuffer",
83         linebuffer_write,
84         linebuffer_read,
85         linebuffer_puts,
86         linebuffer_gets,
87         linebuffer_ctrl,
88         linebuffer_new,
89         linebuffer_free,
90         linebuffer_callback_ctrl,
91         };
92
93 BIO_METHOD *BIO_f_linebuffer(void)
94         {
95         return(&methods_linebuffer);
96         }
97
98 typedef struct bio_linebuffer_ctx_struct
99         {
100         char *obuf;             /* the output char array */
101         int obuf_size;          /* how big is the output buffer */
102         int obuf_len;           /* how many bytes are in it */
103         } BIO_LINEBUFFER_CTX;
104
105 static int linebuffer_new(BIO *bi)
106         {
107         BIO_LINEBUFFER_CTX *ctx;
108
109         ctx=(BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX));
110         if (ctx == NULL) return(0);
111         ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE);
112         if (ctx->obuf == NULL) { OPENSSL_free(ctx); return(0); }
113         ctx->obuf_size=DEFAULT_LINEBUFFER_SIZE;
114         ctx->obuf_len=0;
115
116         bi->init=1;
117         bi->ptr=(char *)ctx;
118         bi->flags=0;
119         return(1);
120         }
121
122 static int linebuffer_free(BIO *a)
123         {
124         BIO_LINEBUFFER_CTX *b;
125
126         if (a == NULL) return(0);
127         b=(BIO_LINEBUFFER_CTX *)a->ptr;
128         if (b->obuf != NULL) OPENSSL_free(b->obuf);
129         OPENSSL_free(a->ptr);
130         a->ptr=NULL;
131         a->init=0;
132         a->flags=0;
133         return(1);
134         }
135         
136 static int linebuffer_read(BIO *b, char *out, int outl)
137         {
138         int ret=0;
139  
140         if (out == NULL) return(0);
141         if (b->next_bio == NULL) return(0);
142         ret=BIO_read(b->next_bio,out,outl);
143         BIO_clear_retry_flags(b);
144         BIO_copy_next_retry(b);
145         return(ret);
146         }
147
148 static int linebuffer_write(BIO *b, const char *in, int inl)
149         {
150         int i,num=0,foundnl;
151         BIO_LINEBUFFER_CTX *ctx;
152
153         if ((in == NULL) || (inl <= 0)) return(0);
154         ctx=(BIO_LINEBUFFER_CTX *)b->ptr;
155         if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
156
157         BIO_clear_retry_flags(b);
158
159         do
160                 {
161                 const char *p;
162
163                 for(p = in; p < in + inl && *p != '\n'; p++)
164                         ;
165                 if (*p == '\n')
166                         {
167                         p++;
168                         foundnl = 1;
169                         }
170                 else
171                         foundnl = 0;
172
173                 /* If a NL was found and we already have text in the save
174                    buffer, concatenate them and write */
175                 while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len)
176                         && ctx->obuf_len > 0)
177                         {
178                         int orig_olen = ctx->obuf_len;
179                         
180                         i = ctx->obuf_size - ctx->obuf_len;
181                         if (p - in > 0)
182                                 {
183                                 if (i >= p - in)
184                                         {
185                                         memcpy(&(ctx->obuf[ctx->obuf_len]),
186                                                 in,p - in);
187                                         ctx->obuf_len += p - in;
188                                         inl -= p - in;
189                                         num += p - in;
190                                         in = p;
191                                         }
192                                 else
193                                         {
194                                         memcpy(&(ctx->obuf[ctx->obuf_len]),
195                                                 in,i);
196                                         ctx->obuf_len += i;
197                                         inl -= i;
198                                         in += i;
199                                         num += i;
200                                         }
201                                 }
202
203 #if 0
204 BIO_write(b->next_bio, "<*<", 3);
205 #endif
206                         i=BIO_write(b->next_bio,
207                                 ctx->obuf, ctx->obuf_len);
208                         if (i <= 0)
209                                 {
210                                 ctx->obuf_len = orig_olen;
211                                 BIO_copy_next_retry(b);
212
213 #if 0
214 BIO_write(b->next_bio, ">*>", 3);
215 #endif
216                                 if (i < 0) return((num > 0)?num:i);
217                                 if (i == 0) return(num);
218                                 }
219 #if 0
220 BIO_write(b->next_bio, ">*>", 3);
221 #endif
222                         if (i < ctx->obuf_len)
223                                 memmove(ctx->obuf, ctx->obuf + i,
224                                         ctx->obuf_len - i);
225                         ctx->obuf_len-=i;
226                         }
227
228                 /* Now that the save buffer is emptied, let's write the input
229                    buffer if a NL was found and there is anything to write. */
230                 if ((foundnl || p - in > ctx->obuf_size) && p - in > 0)
231                         {
232 #if 0
233 BIO_write(b->next_bio, "<*<", 3);
234 #endif
235                         i=BIO_write(b->next_bio,in,p - in);
236                         if (i <= 0)
237                                 {
238                                 BIO_copy_next_retry(b);
239 #if 0
240 BIO_write(b->next_bio, ">*>", 3);
241 #endif
242                                 if (i < 0) return((num > 0)?num:i);
243                                 if (i == 0) return(num);
244                                 }
245 #if 0
246 BIO_write(b->next_bio, ">*>", 3);
247 #endif
248                         num+=i;
249                         in+=i;
250                         inl-=i;
251                         }
252                 }
253         while(foundnl && inl > 0);
254         /* We've written as much as we can.  The rest of the input buffer, if
255            any, is text that doesn't and with a NL and therefore needs to be
256            saved for the next trip. */
257         if (inl > 0)
258                 {
259                 memcpy(&(ctx->obuf[ctx->obuf_len]), in, inl);
260                 ctx->obuf_len += inl;
261                 num += inl;
262                 }
263         return num;
264         }
265
266 static long linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr)
267         {
268         BIO *dbio;
269         BIO_LINEBUFFER_CTX *ctx;
270         long ret=1;
271         char *p;
272         int r;
273         int obs;
274
275         ctx=(BIO_LINEBUFFER_CTX *)b->ptr;
276
277         switch (cmd)
278                 {
279         case BIO_CTRL_RESET:
280                 ctx->obuf_len=0;
281                 if (b->next_bio == NULL) return(0);
282                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
283                 break;
284         case BIO_CTRL_INFO:
285                 ret=(long)ctx->obuf_len;
286                 break;
287         case BIO_CTRL_WPENDING:
288                 ret=(long)ctx->obuf_len;
289                 if (ret == 0)
290                         {
291                         if (b->next_bio == NULL) return(0);
292                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
293                         }
294                 break;
295         case BIO_C_SET_BUFF_SIZE:
296                 obs=(int)num;
297                 p=ctx->obuf;
298                 if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size))
299                         {
300                         p=(char *)OPENSSL_malloc((int)num);
301                         if (p == NULL)
302                                 goto malloc_error;
303                         }
304                 if (ctx->obuf != p)
305                         {
306                         if (ctx->obuf_len > obs)
307                                 {
308                                 ctx->obuf_len = obs;
309                                 }
310                         memcpy(p, ctx->obuf, ctx->obuf_len);
311                         OPENSSL_free(ctx->obuf);
312                         ctx->obuf=p;
313                         ctx->obuf_size=obs;
314                         }
315                 break;
316         case BIO_C_DO_STATE_MACHINE:
317                 if (b->next_bio == NULL) return(0);
318                 BIO_clear_retry_flags(b);
319                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
320                 BIO_copy_next_retry(b);
321                 break;
322
323         case BIO_CTRL_FLUSH:
324                 if (b->next_bio == NULL) return(0);
325                 if (ctx->obuf_len <= 0)
326                         {
327                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
328                         break;
329                         }
330
331                 for (;;)
332                         {
333                         BIO_clear_retry_flags(b);
334                         if (ctx->obuf_len > 0)
335                                 {
336                                 r=BIO_write(b->next_bio,
337                                         ctx->obuf, ctx->obuf_len);
338 #if 0
339 fprintf(stderr,"FLUSH %3d -> %3d\n",ctx->obuf_len,r);
340 #endif
341                                 BIO_copy_next_retry(b);
342                                 if (r <= 0) return((long)r);
343                                 if (r < ctx->obuf_len)
344                                         memmove(ctx->obuf, ctx->obuf + r,
345                                                 ctx->obuf_len - r);
346                                 ctx->obuf_len-=r;
347                                 }
348                         else
349                                 {
350                                 ctx->obuf_len=0;
351                                 ret=1;
352                                 break;
353                                 }
354                         }
355                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
356                 break;
357         case BIO_CTRL_DUP:
358                 dbio=(BIO *)ptr;
359                 if (    !BIO_set_write_buffer_size(dbio,ctx->obuf_size))
360                         ret=0;
361                 break;
362         default:
363                 if (b->next_bio == NULL) return(0);
364                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
365                 break;
366                 }
367         return(ret);
368 malloc_error:
369         BIOerr(BIO_F_LINEBUFFER_CTRL,ERR_R_MALLOC_FAILURE);
370         return(0);
371         }
372
373 static long linebuffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
374         {
375         long ret=1;
376
377         if (b->next_bio == NULL) return(0);
378         switch (cmd)
379                 {
380         default:
381                 ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
382                 break;
383                 }
384         return(ret);
385         }
386
387 static int linebuffer_gets(BIO *b, char *buf, int size)
388         {
389         if (b->next_bio == NULL) return(0);
390         return(BIO_gets(b->next_bio,buf,size));
391         }
392
393 static int linebuffer_puts(BIO *b, const char *str)
394         {
395         return(linebuffer_write(b,str,strlen(str)));
396         }
397