glib/gbase64.c

   1 /* gbase64.c - Base64 encoding/decoding
   2  *
   3  *  Copyright (C) 2006 Alexander Larsson <alexl@redhat.com>
   4  *  Copyright (C) 2000-2003 Ximian Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * This is based on code in camel, written by:
  22  *    Michael Zucchi <notzed@ximian.com>
  23  *    Jeffrey Stedfast <fejj@ximian.com>
  24  */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29
  30 #include "gbase64.h"
  31 #include "glib.h"
  32 #include "glibintl.h"
  33
  34 #include "galias.h"
  35
  36 /**
  37  * SECTION:base64 Base64 Encoding
  38  * @short_description: encodes and decodes data in Base64 format
  39  *
  40  * Base64 is an encoding that allows a sequence of arbitrary bytes to be
  41  * encoded as a sequence of printable ASCII characters. For the definition
  42  * of Base64, see <ulink url="http://www.ietf.org/rfc/rfc1421.txt">RFC
  43  * 1421</ulink> or <ulink url="http://www.ietf.org/rfc/rfc2045.txt">RFC
  44  * 2045</ulink>. Base64 is most commonly used as a MIME transfer encoding
  45  * for email.
  46  *
  47  * GLib supports incremental encoding using g_base64_encode_step() and
  48  * g_base64_encode_close(). Incremental decoding can be done with
  49  * g_base64_decode_step(). To encode or decode data in one go, use
  50  * g_base64_encode() or g_base64_decode(). To avoid memory allocation when
  51  * decoding, you can use g_base64_decode_inplace().
  52  *
  53  * Support for Base64 encoding has been added in GLib 2.12.
  54  */
  55
  56 static const char base64_alphabet[] =
  57         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  58
  59 /**
  60  * g_base64_encode_step:
  61  * @in: the binary data to encode
  62  * @len: the length of @in
  63  * @break_lines: whether to break long lines
  64  * @out: pointer to destination buffer
  65  * @state: Saved state between steps, initialize to 0
  66  * @save: Saved state between steps, initialize to 0
  67  *
  68  * Incrementally encode a sequence of binary data into its Base-64 stringified
  69  * representation. By calling this function multiple times you can convert
  70  * data in chunks to avoid having to have the full encoded data in memory.
  71  *
  72  * When all of the data has been converted you must call
  73  * g_base64_encode_close() to flush the saved state.
  74  *
  75  * The output buffer must be large enough to fit all the data that will
  76  * be written to it. Due to the way base64 encodes you will need
  77  * at least: (@len / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of
  78  * non-zero state). If you enable line-breaking you will need at least:
  79  * ((@len / 3 + 1) * 4 + 4) / 72 + 1 bytes of extra space.
  80  *
  81  * @break_lines is typically used when putting base64-encoded data in emails.
  82  * It breaks the lines at 72 columns instead of putting all of the text on
  83  * the same line. This avoids problems with long lines in the email system.
  84  *
  85  * Return value: The number of bytes of output that was written
  86  *
  87  * Since: 2.12
  88  */
  89 gsize
  90 g_base64_encode_step (const guchar *in,
  91                       gsize         len,
  92                       gboolean      break_lines,
  93                       gchar        *out,
  94                       gint         *state,
  95                       gint         *save)
  96 {
  97   char *outptr;
  98   const guchar *inptr;
  99
 100   g_return_val_if_fail (in != NULL, 0);
 101   g_return_val_if_fail (out != NULL, 0);
 102   g_return_val_if_fail (state != NULL, 0);
 103   g_return_val_if_fail (save != NULL, 0);
 104
 105   if (len <= 0)
 106     return 0;
 107
 108   inptr = in;
 109   outptr = out;
 110
 111   if (len + ((char *) save) [0] > 2)
 112     {
 113       const guchar *inend = in+len-2;
 114       int c1, c2, c3;
 115       int already;
 116
 117       already = *state;
 118
 119       switch (((char *) save) [0])
 120         {
 121         case 1:
 122           c1 = ((unsigned char *) save) [1];
 123           goto skip1;
 124         case 2:
 125           c1 = ((unsigned char *) save) [1];
 126           c2 = ((unsigned char *) save) [2];
 127           goto skip2;
 128         }
 129
 130       /*
 131        * yes, we jump into the loop, no i'm not going to change it,
 132        * it's beautiful!
 133        */
 134       while (inptr < inend)
 135         {
 136           c1 = *inptr++;
 137         skip1:
 138           c2 = *inptr++;
 139         skip2:
 140           c3 = *inptr++;
 141           *outptr++ = base64_alphabet [ c1 >> 2 ];
 142           *outptr++ = base64_alphabet [ c2 >> 4 |
 143                                         ((c1&0x3) << 4) ];
 144           *outptr++ = base64_alphabet [ ((c2 &0x0f) << 2) |
 145                                         (c3 >> 6) ];
 146           *outptr++ = base64_alphabet [ c3 & 0x3f ];
 147           /* this is a bit ugly ... */
 148           if (break_lines && (++already) >= 19)
 149             {
 150               *outptr++ = '\n';
 151               already = 0;
 152             }
 153         }
 154
 155       ((char *)save)[0] = 0;
 156       len = 2 - (inptr - inend);
 157       *state = already;
 158     }
 159
 160   if (len>0)
 161     {
 162       char *saveout;
 163
 164       /* points to the slot for the next char to save */
 165       saveout = & (((char *)save)[1]) + ((char *)save)[0];
 166
 167       /* len can only be 0 1 or 2 */
 168       switch(len)
 169         {
 170         case 2: *saveout++ = *inptr++;
 171         case 1: *saveout++ = *inptr++;
 172         }
 173       ((char *)save)[0] += len;
 174     }
 175
 176   return outptr - out;
 177 }
 178
 179 /**
 180  * g_base64_encode_close:
 181  * @break_lines: whether to break long lines
 182  * @out: pointer to destination buffer
 183  * @state: Saved state from g_base64_encode_step()
 184  * @save: Saved state from g_base64_encode_step()
 185  *
 186  * Flush the status from a sequence of calls to g_base64_encode_step().
 187  *
 188  * Return value: The number of bytes of output that was written
 189  *
 190  * Since: 2.12
 191  */
 192 gsize
 193 g_base64_encode_close (gboolean  break_lines,
 194                        gchar    *out,
 195                        gint     *state,
 196                        gint     *save)
 197 {
 198   int c1, c2;
 199   char *outptr = out;
 200
 201   g_return_val_if_fail (out != NULL, 0);
 202   g_return_val_if_fail (state != NULL, 0);
 203   g_return_val_if_fail (save != NULL, 0);
 204
 205   c1 = ((unsigned char *) save) [1];
 206   c2 = ((unsigned char *) save) [2];
 207
 208   switch (((char *) save) [0])
 209     {
 210     case 2:
 211       outptr [2] = base64_alphabet[ ( (c2 &0x0f) << 2 ) ];
 212       g_assert (outptr [2] != 0);
 213       goto skip;
 214     case 1:
 215       outptr[2] = '=';
 216     skip:
 217       outptr [0] = base64_alphabet [ c1 >> 2 ];
 218       outptr [1] = base64_alphabet [ c2 >> 4 | ( (c1&0x3) << 4 )];
 219       outptr [3] = '=';
 220       outptr += 4;
 221       break;
 222     }
 223   if (break_lines)
 224     *outptr++ = '\n';
 225
 226   *save = 0;
 227   *state = 0;
 228
 229   return outptr - out;
 230 }
 231
 232 /**
 233  * g_base64_encode:
 234  * @data: the binary data to encode
 235  * @len: the length of @data
 236  *
 237  * Encode a sequence of binary data into its Base-64 stringified
 238  * representation.
 239  *
 240  * Return value: a newly allocated, zero-terminated Base-64 encoded
 241  *               string representing @data. The returned string must
 242  *               be freed with g_free().
 243  *
 244  * Since: 2.12
 245  */
 246 gchar *
 247 g_base64_encode (const guchar *data,
 248                  gsize         len)
 249 {
 250   gchar *out;
 251   gint state = 0, outlen;
 252   gint save = 0;
 253
 254   g_return_val_if_fail (data != NULL, NULL);
 255   g_return_val_if_fail (len > 0, NULL);
 256
 257   /* We can use a smaller limit here, since we know the saved state is 0,
 258      +1 is needed for trailing \0, also check for unlikely integer overflow */
 259   if (len >= ((G_MAXSIZE - 1) / 4 - 1) * 3)
 260     g_error("%s: input too large for Base64 encoding (%"G_GSIZE_FORMAT" chars)",
 261         G_STRLOC, len);
 262
 263   out = g_malloc ((len / 3 + 1) * 4 + 1);
 264
 265   outlen = g_base64_encode_step (data, len, FALSE, out, &state, &save);
 266   outlen += g_base64_encode_close (FALSE, out + outlen, &state, &save);
 267   out[outlen] = '\0';
 268
 269   return (gchar *) out;
 270 }
 271
 272 static const unsigned char mime_base64_rank[256] = {
 273   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 274   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 275   255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
 276    52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
 277   255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
 278    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
 279   255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
 280    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
 281   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 282   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 283   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 284   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 285   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 286   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 287   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 288   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 289 };
 290
 291 /**
 292  * g_base64_decode_step:
 293  * @in: binary input data
 294  * @len: max length of @in data to decode
 295  * @out: output buffer
 296  * @state: Saved state between steps, initialize to 0
 297  * @save: Saved state between steps, initialize to 0
 298  *
 299  * Incrementally decode a sequence of binary data from its Base-64 stringified
 300  * representation. By calling this function multiple times you can convert
 301  * data in chunks to avoid having to have the full encoded data in memory.
 302  *
 303  * The output buffer must be large enough to fit all the data that will
 304  * be written to it. Since base64 encodes 3 bytes in 4 chars you need
 305  * at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero
 306  * state).
 307  *
 308  * Return value: The number of bytes of output that was written
 309  *
 310  * Since: 2.12
 311  **/
 312 gsize
 313 g_base64_decode_step (const gchar  *in,
 314                       gsize         len,
 315                       guchar       *out,
 316                       gint         *state,
 317                       guint        *save)
 318 {
 319   const guchar *inptr;
 320   guchar *outptr;
 321   const guchar *inend;
 322   guchar c, rank;
 323   guchar last[2];
 324   unsigned int v;
 325   int i;
 326
 327   g_return_val_if_fail (in != NULL, 0);
 328   g_return_val_if_fail (out != NULL, 0);
 329   g_return_val_if_fail (state != NULL, 0);
 330   g_return_val_if_fail (save != NULL, 0);
 331
 332   if (len <= 0)
 333     return 0;
 334
 335   inend = (const guchar *)in+len;
 336   outptr = out;
 337
 338   /* convert 4 base64 bytes to 3 normal bytes */
 339   v=*save;
 340   i=*state;
 341   inptr = (const guchar *)in;
 342   last[0] = last[1] = 0;
 343   while (inptr < inend)
 344     {
 345       c = *inptr++;
 346       rank = mime_base64_rank [c];
 347       if (rank != 0xff)
 348         {
 349           last[1] = last[0];
 350           last[0] = c;
 351           v = (v<<6) | rank;
 352           i++;
 353           if (i==4)
 354             {
 355               *outptr++ = v>>16;
 356               if (last[1] != '=')
 357                 *outptr++ = v>>8;
 358               if (last[0] != '=')
 359                 *outptr++ = v;
 360               i=0;
 361             }
 362         }
 363     }
 364
 365   *save = v;
 366   *state = i;
 367
 368   return outptr - out;
 369 }
 370
 371 /**
 372  * g_base64_decode:
 373  * @text: zero-terminated string with base64 text to decode
 374  * @out_len: The length of the decoded data is written here
 375  *
 376  * Decode a sequence of Base-64 encoded text into binary data
 377  *
 378  * Return value: a newly allocated buffer containing the binary data
 379  *               that @text represents. The returned buffer must
 380  *               be freed with g_free().
 381  *
 382  * Since: 2.12
 383  */
 384 guchar *
 385 g_base64_decode (const gchar *text,
 386                  gsize       *out_len)
 387 {
 388   guchar *ret;
 389   gsize input_length;
 390   gint state = 0;
 391   guint save = 0;
 392
 393   g_return_val_if_fail (text != NULL, NULL);
 394   g_return_val_if_fail (out_len != NULL, NULL);
 395
 396   input_length = strlen (text);
 397
 398   g_return_val_if_fail (input_length > 1, NULL);
 399
 400   /* We can use a smaller limit here, since we know the saved state is 0,
 401      +1 used to avoid calling g_malloc0(0), and hence retruning NULL */
 402   ret = g_malloc0 ((input_length / 4) * 3 + 1);
 403
 404   *out_len = g_base64_decode_step (text, input_length, ret, &state, &save);
 405
 406   return ret;
 407 }
 408
 409 /**
 410  * g_base64_decode_inplace:
 411  * @text: zero-terminated string with base64 text to decode
 412  * @out_len: The length of the decoded data is written here
 413  *
 414  * Decode a sequence of Base-64 encoded text into binary data
 415  * by overwriting the input data.
 416  *
 417  * Return value: The binary data that @text responds. This pointer
 418  *               is the same as the input @text.
 419  *
 420  * Since: 2.20
 421  */
 422 guchar *
 423 g_base64_decode_inplace (gchar *text,
 424                          gsize *out_len)
 425 {
 426   gint input_length, state = 0;
 427   guint save = 0;
 428
 429   g_return_val_if_fail (text != NULL, NULL);
 430   g_return_val_if_fail (out_len != NULL, NULL);
 431
 432   input_length = strlen (text);
 433
 434   g_return_val_if_fail (input_length > 1, NULL);
 435
 436   *out_len = g_base64_decode_step (text, input_length, (guchar *) text, &state, &save);
 437
 438   return (guchar *) text;
 439 }
 440
 441
 442 #define __G_BASE64_C__
 443 #include "galiasdef.c"