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 static const char base64_alphabet[] =
  37         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  38
  39 /**
  40  * g_base64_encode_step:
  41  * @in: the binary data to encode
  42  * @len: the length of @in
  43  * @break_lines: whether to break long lines
  44  * @out: pointer to destination buffer
  45  * @state: Saved state between steps, initialize to 0
  46  * @save: Saved state between steps, initialize to 0
  47  *
  48  * Incrementally encode a sequence of binary data into it's Base-64 stringified
  49  * representation. By calling this function multiple times you can convert
  50  * data in chunks to avoid having to have the full encoded data in memory.
  51  *
  52  * When all of the data has been converted you must call
  53  * g_base64_encode_close() to flush the saved state.
  54  *
  55  * The output buffer must be large enough to fit all the data that will
  56  * be written to it. Due to the way base64 encodes you will need
  57  * at least: @len * 4 / 3 + 6 bytes. If you enable line-breaking you will
  58  * need at least: @len * 4 / 3 + @len * 4 / (3 * 72) + 7 bytes.
  59  *
  60  * @break_lines is typically used when putting base64-encoded data in emails.
  61  * It breaks the lines at 72 columns instead of putting all of the text on
  62  * the same line. This avoids problems with long lines in the email system.
  63  *
  64  * Return value: The number of bytes of output that was written
  65  *
  66  * Since: 2.12
  67  */
  68 gsize
  69 g_base64_encode_step (const guchar *in,
  70                       gsize         len,
  71                       gboolean      break_lines,
  72                       gchar        *out,
  73                       gint         *state,
  74                       gint         *save)
  75 {
  76   char *outptr;
  77   const guchar *inptr;
  78
  79   g_return_val_if_fail (in != NULL, 0);
  80   g_return_val_if_fail (out != NULL, 0);
  81   g_return_val_if_fail (state != NULL, 0);
  82   g_return_val_if_fail (save != NULL, 0);
  83
  84   if (len <= 0)
  85     return 0;
  86
  87   inptr = in;
  88   outptr = out;
  89
  90   if (len + ((char *) save) [0] > 2)
  91     {
  92       const guchar *inend = in+len-2;
  93       int c1, c2, c3;
  94       int already;
  95
  96       already = *state;
  97
  98       switch (((char *) save) [0])
  99         {
 100         case 1:
 101           c1 = ((unsigned char *) save) [1];
 102           goto skip1;
 103         case 2:
 104           c1 = ((unsigned char *) save) [1];
 105           c2 = ((unsigned char *) save) [2];
 106           goto skip2;
 107         }
 108
 109       /*
 110        * yes, we jump into the loop, no i'm not going to change it,
 111        * it's beautiful!
 112        */
 113       while (inptr < inend)
 114         {
 115           c1 = *inptr++;
 116         skip1:
 117           c2 = *inptr++;
 118         skip2:
 119           c3 = *inptr++;
 120           *outptr++ = base64_alphabet [ c1 >> 2 ];
 121           *outptr++ = base64_alphabet [ c2 >> 4 |
 122                                         ((c1&0x3) << 4) ];
 123           *outptr++ = base64_alphabet [ ((c2 &0x0f) << 2) |
 124                                         (c3 >> 6) ];
 125           *outptr++ = base64_alphabet [ c3 & 0x3f ];
 126           /* this is a bit ugly ... */
 127           if (break_lines && (++already) >= 19)
 128             {
 129               *outptr++ = '\n';
 130               already = 0;
 131             }
 132         }
 133
 134       ((char *)save)[0] = 0;
 135       len = 2 - (inptr - inend);
 136       *state = already;
 137     }
 138
 139   if (len>0)
 140     {
 141       char *saveout;
 142
 143       /* points to the slot for the next char to save */
 144       saveout = & (((char *)save)[1]) + ((char *)save)[0];
 145
 146       /* len can only be 0 1 or 2 */
 147       switch(len)
 148         {
 149         case 2: *saveout++ = *inptr++;
 150         case 1: *saveout++ = *inptr++;
 151         }
 152       ((char *)save)[0] += len;
 153     }
 154
 155   return outptr - out;
 156 }
 157
 158 /**
 159  * g_base64_encode_close:
 160  * @break_lines: whether to break long lines
 161  * @out: pointer to destination buffer
 162  * @state: Saved state from g_base64_encode_step()
 163  * @save: Saved state from g_base64_encode_step()
 164  *
 165  * Flush the status from a sequence of calls to g_base64_encode_step().
 166  *
 167  * Return value: The number of bytes of output that was written
 168  *
 169  * Since: 2.12
 170  */
 171 gsize
 172 g_base64_encode_close (gboolean  break_lines,
 173                        gchar    *out,
 174                        gint     *state,
 175                        gint     *save)
 176 {
 177   int c1, c2;
 178   char *outptr = out;
 179
 180   g_return_val_if_fail (out != NULL, 0);
 181   g_return_val_if_fail (state != NULL, 0);
 182   g_return_val_if_fail (save != NULL, 0);
 183
 184   c1 = ((unsigned char *) save) [1];
 185   c2 = ((unsigned char *) save) [2];
 186
 187   switch (((char *) save) [0])
 188     {
 189     case 2:
 190       outptr [2] = base64_alphabet[ ( (c2 &0x0f) << 2 ) ];
 191       g_assert (outptr [2] != 0);
 192       goto skip;
 193     case 1:
 194       outptr[2] = '=';
 195     skip:
 196       outptr [0] = base64_alphabet [ c1 >> 2 ];
 197       outptr [1] = base64_alphabet [ c2 >> 4 | ( (c1&0x3) << 4 )];
 198       outptr [3] = '=';
 199       outptr += 4;
 200       break;
 201     }
 202   if (break_lines)
 203     *outptr++ = '\n';
 204
 205   *save = 0;
 206   *state = 0;
 207
 208   return outptr - out;
 209 }
 210
 211 /**
 212  * g_base64_encode:
 213  * @data: the binary data to encode
 214  * @len: the length of @data
 215  *
 216  * Encode a sequence of binary data into its Base-64 stringified
 217  * representation.
 218  *
 219  * Return value: a newly allocated, zero-terminated Base-64 encoded
 220  *               string representing @data.
 221  *
 222  * Since: 2.12
 223  */
 224 gchar *
 225 g_base64_encode (const guchar *data,
 226                  gsize         len)
 227 {
 228   gchar *out;
 229   gint state = 0, outlen;
 230   gint save = 0;
 231
 232   g_return_val_if_fail (data != NULL, NULL);
 233   g_return_val_if_fail (len > 1, NULL);
 234
 235   /* We can use a smaller limit here, since we know the saved state is 0 */
 236   out = g_malloc (len * 4 / 3 + 4);
 237   outlen = g_base64_encode_step (data, len, FALSE, out, &state, &save);
 238   outlen += g_base64_encode_close (FALSE,
 239                                    out + outlen,
 240                                    &state,
 241                                    &save);
 242   out[outlen] = '\0';
 243   return (gchar *) out;
 244 }
 245
 246 static const unsigned char mime_base64_rank[256] = {
 247   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 248   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 249   255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
 250    52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
 251   255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
 252    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
 253   255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
 254    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
 255   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 256   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 257   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 258   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 259   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 260   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 261   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 262   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 263 };
 264
 265 /**
 266  * g_base64_decode_step:
 267  * @in: binary input data
 268  * @len: max length of @in data to decode
 269  * @out: output buffer
 270  * @state: Saved state between steps, initialize to 0
 271  * @save: Saved state between steps, initialize to 0
 272  *
 273  * Incrementally decode a sequence of binary data from its Base-64 stringified
 274  * representation. By calling this function multiple times you can convert
 275  * data in chunks to avoid having to have the full encoded data in memory.
 276  *
 277  * The output buffer must be large enough to fit all the data that will
 278  * be written to it. Since base64 encodes 3 bytes in 4 chars you need
 279  * at least: @len * 3 / 4 bytes.
 280  *
 281  * Return value: The number of bytes of output that was written
 282  *
 283  * Since: 2.12
 284  **/
 285 gsize
 286 g_base64_decode_step (const gchar  *in,
 287                       gsize         len,
 288                       guchar       *out,
 289                       gint         *state,
 290                       guint        *save)
 291 {
 292   const guchar *inptr;
 293   guchar *outptr;
 294   const guchar *inend;
 295   guchar c, rank;
 296   guchar last[2];
 297   unsigned int v;
 298   int i;
 299
 300   g_return_val_if_fail (in != NULL, 0);
 301   g_return_val_if_fail (out != NULL, 0);
 302   g_return_val_if_fail (state != NULL, 0);
 303   g_return_val_if_fail (save != NULL, 0);
 304
 305   if (len <= 0)
 306     return 0;
 307
 308   inend = (const guchar *)in+len;
 309   outptr = out;
 310
 311   /* convert 4 base64 bytes to 3 normal bytes */
 312   v=*save;
 313   i=*state;
 314   inptr = (const guchar *)in;
 315   last[0] = last[1] = 0;
 316   while (inptr < inend)
 317     {
 318       c = *inptr++;
 319       rank = mime_base64_rank [c];
 320       if (rank != 0xff)
 321         {
 322           last[1] = last[0];
 323           last[0] = c;
 324           v = (v<<6) | rank;
 325           i++;
 326           if (i==4)
 327             {
 328               *outptr++ = v>>16;
 329               if (last[1] != '=')
 330                 *outptr++ = v>>8;
 331               if (last[0] != '=')
 332                 *outptr++ = v;
 333               i=0;
 334             }
 335         }
 336     }
 337
 338   *save = v;
 339   *state = i;
 340
 341   return outptr - out;
 342 }
 343
 344 /**
 345  * g_base64_decode:
 346  * @text: zero-terminated string with base64 text to decode
 347  * @out_len: The length of the decoded data is written here
 348  *
 349  * Decode a sequence of Base-64 encoded text into binary data
 350  *
 351  * Return value: a newly allocated buffer containing the binary data
 352  *               that @text represents
 353  *
 354  * Since: 2.12
 355  */
 356 guchar *
 357 g_base64_decode (const gchar *text,
 358                  gsize       *out_len)
 359 {
 360   guchar *ret;
 361   gint input_length, state = 0;
 362   guint save = 0;
 363
 364   g_return_val_if_fail (text != NULL, NULL);
 365   g_return_val_if_fail (out_len != NULL, NULL);
 366
 367   input_length = strlen (text);
 368
 369   g_return_val_if_fail (input_length > 1, NULL);
 370
 371   ret = g_malloc0 (input_length * 3 / 4);
 372
 373   *out_len = g_base64_decode_step (text, input_length, ret, &state, &save);
 374
 375   return ret;
 376 }
 377
 378 #define __G_BASE64_C__
 379 #include "galiasdef.c"