Update EVP_PKEY_cmp() and X509_check_private() to return sensible values and

[openssl.git] / crypto / evp / bio_b64.c

diff --git a/crypto/evp/bio_b64.c b/crypto/evp/bio_b64.c
index 35c514a771743d2c4f37edf16b587e848a107479..fa5cbc7eb1ffc68fa212a102856e092c55b6512e 100644 (file)
--- a/crypto/evp/bio_b64.c
+++ b/crypto/evp/bio_b64.c
@@ -165,6 +165,7 @@ static int b64_read(BIO *b, char *out, int outl)
                {
                i=ctx->buf_len-ctx->buf_off;
                if (i > outl) i=outl;
+               OPENSSL_assert(ctx->buf_off+i < (int)sizeof(ctx->buf));
                memcpy(out,&(ctx->buf[ctx->buf_off]),i);
                ret=i;
                out+=i;
@@ -183,7 +184,9 @@ static int b64_read(BIO *b, char *out, int outl)
        ret_code=0;
        while (outl > 0)
                {
-               if (ctx->cont <= 0) break;
+
+               if (ctx->cont <= 0)
+                       break;
 
                i=BIO_read(b->next_bio,&(ctx->tmp[ctx->tmp_len]),
                        B64_BLOCK_SIZE-ctx->tmp_len);
@@ -194,11 +197,21 @@ static int b64_read(BIO *b, char *out, int outl)
 
                        /* 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;
+                               /* If buffer empty break */
+                               if(ctx->tmp_len == 0)
+                                       break;
+                               /* Fall through and process what we have */
+                               else
+                                       i = 0;
+                               }
+                       /* else we retry and add more data to buffer */
+                       else
+                               break;
                        }
                i+=ctx->tmp_len;
+               ctx->tmp_len = i;
 
                /* We need to scan, a line at a time until we
                 * have a valid line if we are starting. */
@@ -254,8 +267,12 @@ static int b64_read(BIO *b, char *out, int outl)
                                 * reading until a new line. */
                                if (p == (unsigned char *)&(ctx->tmp[0]))
                                        {
-                                       ctx->tmp_nl=1;
-                                       ctx->tmp_len=0;
+                                       /* Check buffer full */
+                                       if (i == B64_BLOCK_SIZE)
+                                               {
+                                               ctx->tmp_nl=1;
+                                               ctx->tmp_len=0;
+                                               }
                                        }
                                else if (p != q) /* finished on a '\n' */
                                        {
@@ -270,6 +287,11 @@ static int b64_read(BIO *b, char *out, int outl)
                        else
                                ctx->tmp_len=0;
                        }
+               /* If buffer isn't full and we can retry then
+                * restart to read in more data.
+                */
+               else if ((i < B64_BLOCK_SIZE) && (ctx->cont > 0))
+                       continue;
 
                if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
                        {
@@ -309,8 +331,8 @@ static int b64_read(BIO *b, char *out, int outl)
                        i=EVP_DecodeUpdate(&(ctx->base64),
                                (unsigned char *)ctx->buf,&ctx->buf_len,
                                (unsigned char *)ctx->tmp,i);
+                       ctx->tmp_len = 0;
                        }
-               ctx->cont=i;
                ctx->buf_off=0;
                if (i < 0)
                        {
@@ -370,10 +392,11 @@ static int b64_write(BIO *b, const char *in, int inl)
                n-=i;
                }
        /* at this point all pending data has been written */
+       ctx->buf_off=0;
+       ctx->buf_len=0;
 
        if ((in == NULL) || (inl <= 0)) return(0);
 
-       ctx->buf_off=0;
        while (inl > 0)
                {
                n=(inl > B64_BLOCK_SIZE)?B64_BLOCK_SIZE:inl;
@@ -383,14 +406,20 @@ static int b64_write(BIO *b, const char *in, int inl)
                        if (ctx->tmp_len > 0)
                                {
                                n=3-ctx->tmp_len;
+                               /* There's a teoretical possibility for this */
+                               if (n > inl) 
+                                       n=inl;
                                memcpy(&(ctx->tmp[ctx->tmp_len]),in,n);
                                ctx->tmp_len+=n;
-                               n=ctx->tmp_len;
-                               if (n < 3)
+                               if (ctx->tmp_len < 3)
                                        break;
                                ctx->buf_len=EVP_EncodeBlock(
                                        (unsigned char *)ctx->buf,
-                                       (unsigned char *)ctx->tmp,n);
+                                       (unsigned char *)ctx->tmp,
+                                       ctx->tmp_len);
+                               /* Since we're now done using the temporary
+                                  buffer, the length should be 0'd */
+                               ctx->tmp_len=0;
                                }
                        else
                                {
@@ -458,7 +487,8 @@ static long b64_ctrl(BIO *b, int cmd, long num, void *ptr)
                break;
        case BIO_CTRL_WPENDING: /* More to write in buffer */
                ret=ctx->buf_len-ctx->buf_off;
-               if ((ret == 0) && (ctx->base64.num != 0))
+               if ((ret == 0) && (ctx->encode != B64_NONE)
+                       && (ctx->base64.num != 0))
                        ret=1;
                else if (ret <= 0)
                        ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
@@ -475,10 +505,7 @@ again:
                        {
                        i=b64_write(b,NULL,0);
                        if (i < 0)
-                               {
-                               ret=i;
-                               break;
-                               }
+                               return i;
                        }
                if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
                        {
@@ -493,7 +520,7 @@ again:
                                goto again;
                                }
                        }
-               else if (ctx->base64.num != 0)
+               else if (ctx->encode != B64_NONE && ctx->base64.num != 0)
                        {
                        ctx->buf_off=0;
                        EVP_EncodeFinal(&(ctx->base64),