Attachment #780030 for bug #711180

Attachment #780030: Proposed patch v1.1 for bug #711180

View | Details | Raw Unified | Return to bug 711180
Collapse All | Expand All






#include "plbase64.h"
#include "prlog.h" /* For PR_NOT_REACHED */
#include "prmem.h" /* for malloc / PR_MALLOC */

#include <string.h> /* for strlen */

static unsigned char *base = (unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static PRUint32 lenm = (PRUint32)0;
static PRUint32 dcn = (PRUint32)0;

static void
encode3to4
(
    const unsigned char    *src,
    unsigned char          *dest
)
{


    encode((const unsigned char *)src, srclen, (unsigned char *)dest);
    return dest;
}

static PRInt32
codetovalue
(
    const unsigned char *src,
    PRUint32             num
)
{
    unsigned char c = src[ num + lenm ];
    if( (c >= (unsigned char)'A') && (c <= (unsigned char)'Z') )
    {
        return (PRInt32)(c - (unsigned char)'A');
    }
    else if( (c >= (unsigned char)'a') && (c <= (unsigned char)'z') )
    {
        return ((PRInt32)(c - (unsigned char)'a') +26);
    }

    else if( (unsigned char)'+' == c )
    {
        return (PRInt32)62;
    }
    else if( (unsigned char)'/' == c )
    {
        return (PRInt32)63;
    }
    else if( (unsigned char)'\0' == c )
    {
        return -2;
    }
    else if( (unsigned char)' ' == c || (unsigned char)'\r' == c ||
        (unsigned char)'\n' == c || (unsigned char)'\t' == c ||
        (unsigned char)'\f' == c )
    {
        lenm++;
        return codetovalue(src, num);
    }
    else if( (unsigned char)'=' == c)
    {
        return -3;
    }
    else
    {
        return -1;
    }
}

static PRStatus
decode4to3
(
    const unsigned char    *src,
    unsigned char          *dest
)
{
    PRUint32 b32 = (PRUint32)0;
    PRInt32 bits;
    PRIntn i;
    PRUint32 tlm = lenm;

    for( i = 0; i < 4; i++ )
    {
        bits = codetovalue(src, i);
        if( bits < 0 )
        {
            if( bits < -1 )
            {
                if( i == 0 )
                {
                    return PR_SUCCESS;
                }
                else if( i == 1 )
                {
                    return PR_FAILURE;
                }
                lenm = tlm;
                if( i == 2 )
                {
                    dcn = 2;
                }
                else if( i == 3 )
                {
                    dcn = 3;
                }
            }
            return PR_FAILURE;
        }

        b32 <<= 6;
        b32 |= bits;
    }

    dest[0] = (unsigned char)((b32 >> 16) & 0xFF);

(
    const unsigned char    *src,
    unsigned char          *dest
)
{
    PRUint32 b32 = (PRUint32)0;
    PRInt32 bits;
    PRUint32 ubits;
    PRUint32 tlm = lenm;

    bits = codetovalue(src, 0);
    if( bits < 0 )
    {
        if( bits < -1 )
        {
            return PR_SUCCESS;
        }
        return PR_FAILURE;
    }

    b32 = (PRUint32)bits;
    b32 <<= 6;

    bits = codetovalue(src, 1);
    if( bits < 0 )
    {
        return PR_FAILURE;
    }

    b32 |= (PRUint32)bits;
    b32 <<= 4;

    //tlm = lenm;
    bits = codetovalue(src, 2);
    if( bits < 0 )
    {
        if( bits < -1 )
        {
            lenm = tlm;
            dcn = 2;
        }
        return PR_FAILURE;
    }

    ubits = (PRUint32)bits;
    b32 |= (ubits >> 2);

    dest[0] = (unsigned char)((b32 >> 8) & 0xFF);
    dest[1] = (unsigned char)((b32     ) & 0xFF);

    const unsigned char    *src,
    unsigned char          *dest
)
{
    PRUint32 b32;
    PRUint32 ubits;
    PRInt32 bits;

    bits = codetovalue(src, 0);
    if( bits < 0 )
    {
        if( bits < -1 )
        {
            return PR_SUCCESS;
        }
        return PR_FAILURE;
    }

    ubits = (PRUint32)bits;
    b32 = (ubits << 2);

    bits = codetovalue(src, 1);
    if( bits < 0 )
    {
        return PR_FAILURE;
    }

    ubits = (PRUint32)bits;
    b32 |= (ubits >> 4);


(
    const unsigned char    *src,
    PRUint32                srclen,
    unsigned char          *dest
)
{
    PRStatus rv;

    lenm = 0;
	dcn = 0;
    while( ( srclen - lenm ) >= 4 )
    {
        rv = decode4to3(src, dest);
        if( PR_SUCCESS != rv )
        {
			if( dcn )
			{
				if( dcn == 3 )
				{
					return decode3to2(src, dest);
				}
				else if( dcn == 2 )
				{
					return decode2to1(src, dest);
				}
				else
				{
					PR_NOT_REACHED("coding error");
				}
			}
            return PR_FAILURE;
        }

        src += 4;
        dest += 3;
        srclen -= 4;
    }

    switch( srclen - lenm )
    {
        case 3:
            rv = decode3to2(src, dest);
            break;
        case 2:
            rv = decode2to1(src, dest);
            break;
        case 1:

PL_Base64Decode
(
    const char *src,
    PRUint32    srclen,
    char       *dest
)
{
    PRStatus status;
    PRUint32 i;
    PRBool allocated = PR_FALSE;

    if( (char *)0 == src )
    {
        return (char *)0;
    }

    if( 0 == srclen )
    {
        size_t len = strlen(src);
        srclen = len;
        /* Detect truncation. */
        if( srclen != len )
        {
            return (char *)0;
        }
        for( i = 0; i < strlen(src); i++ ) {
            if ( (unsigned char)' ' == src[i] || (unsigned char)'\r' == src[i] ||
            (unsigned char)'\n' == src[i] || (unsigned char)'\t' == src[i] ||
            (unsigned char)'\f' == src[i] ) {
                srclen -= 1;
            }
        }
    }

    if( srclen && (0 == (srclen & 3)) )
    {
        if( (char)'=' == src[ srclen-1 ] )
        {
            if( (char)'=' == src[ srclen-2 ] )
            {





/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "Base64.h"

#include <math.h>

#include "nsIInputStream.h"
#include "nsStringGlue.h"

#include "plbase64.h"

namespace {

// BEGIN base64 encode code copied and modified from NSPR

    return NS_ERROR_FAILURE;
  }

  // Don't ask PR_Base64Decode to decode the empty string
  if (aString.IsEmpty()) {
    aBinaryData.Truncate();
    return NS_OK;
  }
  
  int32_t binaryDataLen = ((aString.Length() * 3) / 4);

  const char *tmp = aString.BeginReading();
  uint32_t i;
  uint32_t e = 0;
  bool eis = false;
  bool sae = false;
  for( i = 0; i < aString.Length(); i++ ) {
    if ( (unsigned char)' ' == tmp[i] || (unsigned char)'\r' == tmp[i] ||
    (unsigned char)'\n' == tmp[i] || (unsigned char)'\t' == tmp[i] ||
    (unsigned char)'\f' == tmp[i] ) {
      binaryDataLen -= 1;
	  if ( eis && !sae ) {
        binaryDataLen -= 1;
		sae = true;
	  }
    }
	else if ( (unsigned char)'=' == tmp[i] ) {
	  binaryDataLen -= 1;
	  e += 1;
	  eis = true;
	  if ( e > 2 ) {
        aBinaryData.Truncate();
		return NS_ERROR_INVALID_ARG;
	  }
	}
	else if ( eis ) {
      aBinaryData.Truncate();
      return NS_ERROR_INVALID_ARG;
	}
  }
  if (i != 0) {
    binaryDataLen += 1;
  }
  if (i > 4) {
    if (i % 4 == 0) {
      binaryDataLen -= 1;
    }
    binaryDataLen += ceil( (float)( (i - 4) / 4 ) );
  }
  char *buffer;

  // Add one byte for null termination.
  if (aBinaryData.SetCapacity(binaryDataLen + 1, fallible_t()) &&
    (buffer = aBinaryData.BeginWriting()) &&
    PL_Base64Decode(aString.BeginReading(), aString.Length(), buffer)) {
    // PL_Base64Decode doesn't null terminate the buffer for us when we pass
    // the buffer in. Do that manually, taking into account the number of '='

    if (!aString.IsEmpty() && aString[aString.Length() - 1] == '=') {
      if (aString.Length() > 1 && aString[aString.Length() - 2] == '=') {
        binaryDataLen -= 2;
      } else {
        binaryDataLen -= 1;
      }
    }
    buffer[binaryDataLen] = '\0';
  
    aBinaryData.SetLength(binaryDataLen);
    return NS_OK;
  }


  aBinaryData.Truncate();
  return NS_ERROR_INVALID_ARG;
}

nsresult
Base64Decode(const nsAString &aBinaryData, nsAString &aString)
{
  NS_LossyConvertUTF16toASCII binaryData(aBinaryData);

Return to bug 711180