/* crypto/evp/bio_b64.c */
-/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
#include <stdio.h>
#include <errno.h>
#include "cryptlib.h"
-#include "buffer.h"
-#include "evp.h"
+#include <openssl/buffer.h>
+#include <openssl/evp.h>
#ifndef NOPROTO
static int b64_write(BIO *h,char *buf,int num);
#endif
#define B64_BLOCK_SIZE 1024
+#define B64_BLOCK_SIZE2 768
#define B64_NONE 0
#define B64_ENCODE 1
#define B64_DECODE 2
b64_free,
};
-BIO_METHOD *BIO_f_base64()
+BIO_METHOD *BIO_f_base64(void)
{
return(&methods_b64);
}
-static int b64_new(bi)
-BIO *bi;
+static int b64_new(BIO *bi)
{
BIO_B64_CTX *ctx;
return(1);
}
-static int b64_free(a)
-BIO *a;
+static int b64_free(BIO *a)
{
if (a == NULL) return(0);
Free(a->ptr);
return(1);
}
-static int b64_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int b64_read(BIO *b, char *out, int outl)
{
- int ret=0,i,ii,j,k,x,n,num;
+ int ret=0,i,ii,j,k,x,n,num,ret_code=0;
BIO_B64_CTX *ctx;
unsigned char *p,*q;
ctx->encode=B64_DECODE;
ctx->buf_len=0;
ctx->buf_off=0;
+ ctx->tmp_len=0;
EVP_DecodeInit(&(ctx->base64));
}
/* At this point, we have room of outl bytes and an empty
* buffer, so we should read in some more. */
+ ret_code=0;
while (outl > 0)
{
if (ctx->cont <= 0) break;
if (i <= 0)
{
+ ret_code=i;
+
/* Should be continue next time we are called? */
if (!BIO_should_retry(b->next_bio))
ctx->cont=i;
+ /* else we should continue when called again */
break;
}
i+=ctx->tmp_len;
/* We need to scan, a line at a time until we
* have a valid line if we are starting. */
- if (ctx->start)
+ if (ctx->start && (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL))
+ {
+ /* ctx->start=1; */
+ ctx->tmp_len=0;
+ }
+ else if (ctx->start)
{
q=p=(unsigned char *)ctx->tmp;
for (j=0; j<i; j++)
else
ctx->tmp_len=0;
}
- i=EVP_DecodeUpdate(&(ctx->base64),
- (unsigned char *)ctx->buf,&ctx->buf_len,
- (unsigned char *)ctx->tmp,i);
+
+ if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
+ {
+ int z,jj;
+
+ jj=(i>>2)<<2;
+ z=EVP_DecodeBlock((unsigned char *)ctx->buf,
+ (unsigned char *)ctx->tmp,jj);
+ if (jj > 2)
+ {
+ if (ctx->tmp[jj-1] == '=')
+ {
+ z--;
+ if (ctx->tmp[jj-2] == '=')
+ z--;
+ }
+ }
+ /* z is now number of output bytes and jj is the
+ * number consumed */
+ if (jj != i)
+ {
+ memcpy((unsigned char *)ctx->tmp,
+ (unsigned char *)&(ctx->tmp[jj]),i-jj);
+ ctx->tmp_len=i-jj;
+ }
+ ctx->buf_len=0;
+ if (z > 0)
+ {
+ ctx->buf_len=z;
+ i=1;
+ }
+ else
+ i=z;
+ }
+ else
+ {
+ i=EVP_DecodeUpdate(&(ctx->base64),
+ (unsigned char *)ctx->buf,&ctx->buf_len,
+ (unsigned char *)ctx->tmp,i);
+ }
ctx->cont=i;
ctx->buf_off=0;
if (i < 0)
{
+ ret_code=0;
ctx->buf_len=0;
break;
}
}
BIO_clear_retry_flags(b);
BIO_copy_next_retry(b);
- return((ret == 0)?ctx->cont:ret);
+ return((ret == 0)?ret_code:ret);
}
-static int b64_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int b64_write(BIO *b, char *in, int inl)
{
int ret=inl,n,i;
BIO_B64_CTX *ctx;
ctx->encode=B64_ENCODE;
ctx->buf_len=0;
ctx->buf_off=0;
+ ctx->tmp_len=0;
EVP_EncodeInit(&(ctx->base64));
}
while (inl > 0)
{
n=(inl > B64_BLOCK_SIZE)?B64_BLOCK_SIZE:inl;
- EVP_EncodeUpdate(&(ctx->base64),
- (unsigned char *)ctx->buf,&ctx->buf_len,
- (unsigned char *)in,n);
+
+ if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
+ {
+ if (ctx->tmp_len > 0)
+ {
+ n=3-ctx->tmp_len;
+ memcpy(&(ctx->tmp[ctx->tmp_len]),in,n);
+ ctx->tmp_len+=n;
+ n=ctx->tmp_len;
+ if (n < 3)
+ break;
+ ctx->buf_len=EVP_EncodeBlock(
+ (unsigned char *)ctx->buf,
+ (unsigned char *)ctx->tmp,n);
+ }
+ else
+ {
+ if (n < 3)
+ {
+ memcpy(&(ctx->tmp[0]),in,n);
+ ctx->tmp_len=n;
+ break;
+ }
+ n-=n%3;
+ ctx->buf_len=EVP_EncodeBlock(
+ (unsigned char *)ctx->buf,
+ (unsigned char *)in,n);
+ }
+ }
+ else
+ {
+ EVP_EncodeUpdate(&(ctx->base64),
+ (unsigned char *)ctx->buf,&ctx->buf_len,
+ (unsigned char *)in,n);
+ }
inl-=n;
in+=n;
return(ret);
}
-static long b64_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long b64_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO_B64_CTX *ctx;
long ret=1;
break;
}
}
- if (ctx->base64.num != 0)
+ if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
+ {
+ if (ctx->tmp_len != 0)
+ {
+ ctx->buf_len=EVP_EncodeBlock(
+ (unsigned char *)ctx->buf,
+ (unsigned char *)ctx->tmp,
+ ctx->tmp_len);
+ ctx->buf_off=0;
+ ctx->tmp_len=0;
+ goto again;
+ }
+ }
+ else if (ctx->base64.num != 0)
{
ctx->buf_off=0;
EVP_EncodeFinal(&(ctx->base64),