nsprpub/lib/libc/src/base64.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is the Netscape Portable Runtime (NSPR).
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998-2000
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "plbase64.h"
  39 #include "prlog.h" /* For PR_NOT_REACHED */
  40 #include "prmem.h" /* for malloc / PR_MALLOC */
  41 #include "plstr.h" /* for PL_strlen */
  42
  43 static unsigned char *base = (unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  44
  45 static void
  46 encode3to4
  47 (
  48     const unsigned char    *src,
  49     unsigned char          *dest
  50 )
  51 {
  52     PRUint32 b32 = (PRUint32)0;
  53     PRIntn i, j = 18;
  54
  55     for( i = 0; i < 3; i++ )
  56     {
  57         b32 <<= 8;
  58         b32 |= (PRUint32)src[i];
  59     }
  60
  61     for( i = 0; i < 4; i++ )
  62     {
  63         dest[i] = base[ (PRUint32)((b32>>j) & 0x3F) ];
  64         j -= 6;
  65     }
  66
  67     return;
  68 }
  69
  70 static void
  71 encode2to4
  72 (
  73     const unsigned char    *src,
  74     unsigned char          *dest
  75 )
  76 {
  77     dest[0] = base[ (PRUint32)((src[0]>>2) & 0x3F) ];
  78     dest[1] = base[ (PRUint32)(((src[0] & 0x03) << 4) | ((src[1] >> 4) & 0x0F)) ];
  79     dest[2] = base[ (PRUint32)((src[1] & 0x0F) << 2) ];
  80     dest[3] = (unsigned char)'=';
  81     return;
  82 }
  83
  84 static void
  85 encode1to4
  86 (
  87     const unsigned char    *src,
  88     unsigned char          *dest
  89 )
  90 {
  91     dest[0] = base[ (PRUint32)((src[0]>>2) & 0x3F) ];
  92     dest[1] = base[ (PRUint32)((src[0] & 0x03) << 4) ];
  93     dest[2] = (unsigned char)'=';
  94     dest[3] = (unsigned char)'=';
  95     return;
  96 }
  97
  98 static void
  99 encode
 100 (
 101     const unsigned char    *src,
 102     PRUint32                srclen,
 103     unsigned char          *dest
 104 )
 105 {
 106     while( srclen >= 3 )
 107     {
 108         encode3to4(src, dest);
 109         src += 3;
 110         dest += 4;
 111         srclen -= 3;
 112     }
 113
 114     switch( srclen )
 115     {
 116         case 2:
 117             encode2to4(src, dest);
 118             break;
 119         case 1:
 120             encode1to4(src, dest);
 121             break;
 122         case 0:
 123             break;
 124         default:
 125             PR_NOT_REACHED("coding error");
 126     }
 127
 128     return;
 129 }
 130
 131 /*
 132  * PL_Base64Encode
 133  *
 134  * If the destination argument is NULL, a return buffer is
 135  * allocated, and the data therein will be null-terminated.
 136  * If the destination argument is not NULL, it is assumed to
 137  * be of sufficient size, and the contents will not be null-
 138  * terminated by this routine.
 139  *
 140  * Returns null if the allocation fails.
 141  */
 142
 143 PR_IMPLEMENT(char *)
 144 PL_Base64Encode
 145 (
 146     const char *src,
 147     PRUint32    srclen,
 148     char       *dest
 149 )
 150 {
 151     if( 0 == srclen )
 152     {
 153         srclen = PL_strlen(src);
 154     }
 155
 156     if( (char *)0 == dest )
 157     {
 158         PRUint32 destlen = ((srclen + 2)/3) * 4;
 159         dest = (char *)PR_MALLOC(destlen + 1);
 160         if( (char *)0 == dest )
 161         {
 162             return (char *)0;
 163         }
 164         dest[ destlen ] = (char)0; /* null terminate */
 165     }
 166
 167     encode((const unsigned char *)src, srclen, (unsigned char *)dest);
 168     return dest;
 169 }
 170
 171 static PRInt32
 172 codetovalue
 173 (
 174     unsigned char c
 175 )
 176 {
 177     if( (c >= (unsigned char)'A') && (c <= (unsigned char)'Z') )
 178     {
 179         return (PRInt32)(c - (unsigned char)'A');
 180     }
 181     else if( (c >= (unsigned char)'a') && (c <= (unsigned char)'z') )
 182     {
 183         return ((PRInt32)(c - (unsigned char)'a') +26);
 184     }
 185     else if( (c >= (unsigned char)'0') && (c <= (unsigned char)'9') )
 186     {
 187         return ((PRInt32)(c - (unsigned char)'0') +52);
 188     }
 189     else if( (unsigned char)'+' == c )
 190     {
 191         return (PRInt32)62;
 192     }
 193     else if( (unsigned char)'/' == c )
 194     {
 195         return (PRInt32)63;
 196     }
 197     else
 198     {
 199         return -1;
 200     }
 201 }
 202
 203 static PRStatus
 204 decode4to3
 205 (
 206     const unsigned char    *src,
 207     unsigned char          *dest
 208 )
 209 {
 210     PRUint32 b32 = (PRUint32)0;
 211     PRInt32 bits;
 212     PRIntn i;
 213
 214     for( i = 0; i < 4; i++ )
 215     {
 216         bits = codetovalue(src[i]);
 217         if( bits < 0 )
 218         {
 219             return PR_FAILURE;
 220         }
 221
 222         b32 <<= 6;
 223         b32 |= bits;
 224     }
 225
 226     dest[0] = (unsigned char)((b32 >> 16) & 0xFF);
 227     dest[1] = (unsigned char)((b32 >>  8) & 0xFF);
 228     dest[2] = (unsigned char)((b32      ) & 0xFF);
 229
 230     return PR_SUCCESS;
 231 }
 232
 233 static PRStatus
 234 decode3to2
 235 (
 236     const unsigned char    *src,
 237     unsigned char          *dest
 238 )
 239 {
 240     PRUint32 b32 = (PRUint32)0;
 241     PRInt32 bits;
 242     PRUint32 ubits;
 243
 244     bits = codetovalue(src[0]);
 245     if( bits < 0 )
 246     {
 247         return PR_FAILURE;
 248     }
 249
 250     b32 = (PRUint32)bits;
 251     b32 <<= 6;
 252
 253     bits = codetovalue(src[1]);
 254     if( bits < 0 )
 255     {
 256         return PR_FAILURE;
 257     }
 258
 259     b32 |= (PRUint32)bits;
 260     b32 <<= 4;
 261
 262     bits = codetovalue(src[2]);
 263     if( bits < 0 )
 264     {
 265         return PR_FAILURE;
 266     }
 267
 268     ubits = (PRUint32)bits;
 269     b32 |= (ubits >> 2);
 270
 271     dest[0] = (unsigned char)((b32 >> 8) & 0xFF);
 272     dest[1] = (unsigned char)((b32     ) & 0xFF);
 273
 274     return PR_SUCCESS;
 275 }
 276
 277 static PRStatus
 278 decode2to1
 279 (
 280     const unsigned char    *src,
 281     unsigned char          *dest
 282 )
 283 {
 284     PRUint32 b32;
 285     PRUint32 ubits;
 286     PRInt32 bits;
 287
 288     bits = codetovalue(src[0]);
 289     if( bits < 0 )
 290     {
 291         return PR_FAILURE;
 292     }
 293
 294     ubits = (PRUint32)bits;
 295     b32 = (ubits << 2);
 296
 297     bits = codetovalue(src[1]);
 298     if( bits < 0 )
 299     {
 300         return PR_FAILURE;
 301     }
 302
 303     ubits = (PRUint32)bits;
 304     b32 |= (ubits >> 4);
 305
 306     dest[0] = (unsigned char)b32;
 307
 308     return PR_SUCCESS;
 309 }
 310
 311 static PRStatus
 312 decode
 313 (
 314     const unsigned char    *src,
 315     PRUint32                srclen,
 316     unsigned char          *dest
 317 )
 318 {
 319     PRStatus rv;
 320
 321     while( srclen >= 4 )
 322     {
 323         rv = decode4to3(src, dest);
 324         if( PR_SUCCESS != rv )
 325         {
 326             return PR_FAILURE;
 327         }
 328
 329         src += 4;
 330         dest += 3;
 331         srclen -= 4;
 332     }
 333
 334     switch( srclen )
 335     {
 336         case 3:
 337             rv = decode3to2(src, dest);
 338             break;
 339         case 2:
 340             rv = decode2to1(src, dest);
 341             break;
 342         case 1:
 343             rv = PR_FAILURE;
 344             break;
 345         case 0:
 346             rv = PR_SUCCESS;
 347             break;
 348         default:
 349             PR_NOT_REACHED("coding error");
 350     }
 351
 352     return rv;
 353 }
 354
 355 /*
 356  * PL_Base64Decode
 357  *
 358  * If the destination argument is NULL, a return buffer is
 359  * allocated and the data therein will be null-terminated.
 360  * If the destination argument is not null, it is assumed
 361  * to be of sufficient size, and the data will not be null-
 362  * terminated by this routine.
 363  *
 364  * Returns null if the allocation fails, or if the source string is
 365  * not well-formed.
 366  */
 367
 368 PR_IMPLEMENT(char *)
 369 PL_Base64Decode
 370 (
 371     const char *src,
 372     PRUint32    srclen,
 373     char       *dest
 374 )
 375 {
 376     PRStatus status;
 377     PRBool allocated = PR_FALSE;
 378
 379     if( (char *)0 == src )
 380     {
 381         return (char *)0;
 382     }
 383
 384     if( 0 == srclen )
 385     {
 386         srclen = PL_strlen(src);
 387     }
 388
 389     if( srclen && (0 == (srclen & 3)) )
 390     {
 391         if( (char)'=' == src[ srclen-1 ] )
 392         {
 393             if( (char)'=' == src[ srclen-2 ] )
 394             {
 395                 srclen -= 2;
 396             }
 397             else
 398             {
 399                 srclen -= 1;
 400             }
 401         }
 402     }
 403
 404     if( (char *)0 == dest )
 405     {
 406         PRUint32 destlen = ((srclen * 3) / 4);
 407         dest = (char *)PR_MALLOC(destlen + 1);
 408         if( (char *)0 == dest )
 409         {
 410             return (char *)0;
 411         }
 412         dest[ destlen ] = (char)0; /* null terminate */
 413         allocated = PR_TRUE;
 414     }
 415
 416     status = decode((const unsigned char *)src, srclen, (unsigned char *)dest);
 417     if( PR_SUCCESS != status )
 418     {
 419         if( PR_TRUE == allocated )
 420         {
 421             PR_DELETE(dest);
 422         }
 423
 424         return (char *)0;
 425     }
 426
 427     return dest;
 428 }