CMakeLua/Utilities/cmcurl/base64.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  * $Id: base64.c,v 1.2 2007/03/15 19:22:13 andy Exp $
  22  ***************************************************************************/
  23
  24 /* Base64 encoding/decoding
  25  *
  26  * Test harnesses down the bottom - compile with -DTEST_ENCODE for
  27  * a program that will read in raw data from stdin and write out
  28  * a base64-encoded version to stdout, and the length returned by the
  29  * encoding function to stderr. Compile with -DTEST_DECODE for a program that
  30  * will go the other way.
  31  *
  32  * This code will break if int is smaller than 32 bits
  33  */
  34
  35 #include "setup.h"
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 #define _MPRINTF_REPLACE /* use our functions only */
  41 #include <curl/mprintf.h>
  42
  43 #include "urldata.h" /* for the SessionHandle definition */
  44 #include "easyif.h"  /* for Curl_convert_... prototypes */
  45 #include "base64.h"
  46 #include "memory.h"
  47
  48 /* include memdebug.h last */
  49 #include "memdebug.h"
  50
  51 /* ---- Base64 Encoding/Decoding Table --- */
  52 static const char table64[]=
  53   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  54
  55 static void decodeQuantum(unsigned char *dest, const char *src)
  56 {
  57   unsigned int x = 0;
  58   int i;
  59   char *found;
  60
  61   for(i = 0; i < 4; i++) {
  62     if((found = strchr(table64, src[i])))
  63       x = (x << 6) + (unsigned int)(found - table64);
  64     else if(src[i] == '=')
  65       x = (x << 6);
  66   }
  67
  68   dest[2] = (unsigned char)(x & 255);
  69   x >>= 8;
  70   dest[1] = (unsigned char)(x & 255);
  71   x >>= 8;
  72   dest[0] = (unsigned char)(x & 255);
  73 }
  74
  75 /*
  76  * Curl_base64_decode()
  77  *
  78  * Given a base64 string at src, decode it and return an allocated memory in
  79  * the *outptr. Returns the length of the decoded data.
  80  */
  81 size_t Curl_base64_decode(const char *src, unsigned char **outptr)
  82 {
  83   int length = 0;
  84   int equalsTerm = 0;
  85   int i;
  86   int numQuantums;
  87   unsigned char lastQuantum[3];
  88   size_t rawlen=0;
  89   unsigned char *newstr;
  90
  91   *outptr = NULL;
  92
  93   while((src[length] != '=') && src[length])
  94     length++;
  95   /* A maximum of two = padding characters is allowed */
  96   if(src[length] == '=') {
  97     equalsTerm++;
  98     if(src[length+equalsTerm] == '=')
  99       equalsTerm++;
 100   }
 101   numQuantums = (length + equalsTerm) / 4;
 102
 103   /* Don't allocate a buffer if the decoded length is 0 */
 104   if (numQuantums <= 0)
 105     return 0;
 106
 107   rawlen = (numQuantums * 3) - equalsTerm;
 108
 109   /* The buffer must be large enough to make room for the last quantum
 110   (which may be partially thrown out) and the zero terminator. */
 111   newstr = malloc(rawlen+4);
 112   if(!newstr)
 113     return 0;
 114
 115   *outptr = newstr;
 116
 117   /* Decode all but the last quantum (which may not decode to a
 118   multiple of 3 bytes) */
 119   for(i = 0; i < numQuantums - 1; i++) {
 120     decodeQuantum((unsigned char *)newstr, src);
 121     newstr += 3; src += 4;
 122   }
 123
 124   /* This final decode may actually read slightly past the end of the buffer
 125   if the input string is missing pad bytes.  This will almost always be
 126   harmless. */
 127   decodeQuantum(lastQuantum, src);
 128   for(i = 0; i < 3 - equalsTerm; i++)
 129     newstr[i] = lastQuantum[i];
 130
 131   newstr[i] = 0; /* zero terminate */
 132   return rawlen;
 133 }
 134
 135 /*
 136  * Curl_base64_encode()
 137  *
 138  * Returns the length of the newly created base64 string. The third argument
 139  * is a pointer to an allocated area holding the base64 data. If something
 140  * went wrong, -1 is returned.
 141  *
 142  */
 143 size_t Curl_base64_encode(struct SessionHandle *data,
 144                           const char *inp, size_t insize, char **outptr)
 145 {
 146   unsigned char ibuf[3];
 147   unsigned char obuf[4];
 148   int i;
 149   int inputparts;
 150   char *output;
 151   char *base64data;
 152 #ifdef CURL_DOES_CONVERSIONS
 153   char *convbuf;
 154 #endif
 155
 156   char *indata = (char *)inp;
 157
 158   *outptr = NULL; /* set to NULL in case of failure before we reach the end */
 159
 160   if(0 == insize)
 161     insize = strlen(indata);
 162
 163   base64data = output = (char*)malloc(insize*4/3+4);
 164   if(NULL == output)
 165     return 0;
 166
 167 #ifdef CURL_DOES_CONVERSIONS
 168   /*
 169    * The base64 data needs to be created using the network encoding
 170    * not the host encoding.  And we can't change the actual input
 171    * so we copy it to a buffer, translate it, and use that instead.
 172    */
 173   if(data) {
 174     convbuf = (char*)malloc(insize);
 175     if(!convbuf) {
 176       return 0;
 177     }
 178     memcpy(convbuf, indata, insize);
 179     if(CURLE_OK != Curl_convert_to_network(data, convbuf, insize)) {
 180       free(convbuf);
 181       return 0;
 182     }
 183     indata = convbuf; /* switch to the converted buffer */
 184   }
 185 #else
 186   (void)data;
 187 #endif
 188
 189   while(insize > 0) {
 190     for (i = inputparts = 0; i < 3; i++) {
 191       if(insize > 0) {
 192         inputparts++;
 193         ibuf[i] = *indata;
 194         indata++;
 195         insize--;
 196       }
 197       else
 198         ibuf[i] = 0;
 199     }
 200
 201     obuf[0] = (unsigned char)  ((ibuf[0] & 0xFC) >> 2);
 202     obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
 203                                ((ibuf[1] & 0xF0) >> 4));
 204     obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
 205                                ((ibuf[2] & 0xC0) >> 6));
 206     obuf[3] = (unsigned char)   (ibuf[2] & 0x3F);
 207
 208     switch(inputparts) {
 209     case 1: /* only one byte read */
 210       snprintf(output, 5, "%c%c==",
 211                table64[obuf[0]],
 212                table64[obuf[1]]);
 213       break;
 214     case 2: /* two bytes read */
 215       snprintf(output, 5, "%c%c%c=",
 216                table64[obuf[0]],
 217                table64[obuf[1]],
 218                table64[obuf[2]]);
 219       break;
 220     default:
 221       snprintf(output, 5, "%c%c%c%c",
 222                table64[obuf[0]],
 223                table64[obuf[1]],
 224                table64[obuf[2]],
 225                table64[obuf[3]] );
 226       break;
 227     }
 228     output += 4;
 229   }
 230   *output=0;
 231   *outptr = base64data; /* make it return the actual data memory */
 232
 233 #ifdef CURL_DOES_CONVERSIONS
 234   if(data)
 235     free(convbuf);
 236 #endif
 237   return strlen(base64data); /* return the length of the new data */
 238 }
 239 /* ---- End of Base64 Encoding ---- */
 240
 241 /************* TEST HARNESS STUFF ****************/
 242
 243
 244 #ifdef TEST_ENCODE
 245 /* encoding test harness. Read in standard input and write out the length
 246  * returned by Curl_base64_encode, followed by the base64'd data itself
 247  */
 248 #include <stdio.h>
 249
 250 #define TEST_NEED_SUCK
 251 void *suck(int *);
 252
 253 int main(int argc, char **argv, char **envp)
 254 {
 255   char *base64;
 256   size_t base64Len;
 257   unsigned char *data;
 258   int dataLen;
 259   struct SessionHandle *handle = NULL;
 260
 261 #ifdef CURL_DOES_CONVERSIONS
 262   /* get a Curl handle so Curl_base64_encode can translate properly */
 263   handle = curl_easy_init();
 264   if(handle == NULL) {
 265     fprintf(stderr, "Error: curl_easy_init failed\n");
 266     return 0;
 267   }
 268 #endif
 269   data = (unsigned char *)suck(&dataLen);
 270   base64Len = Curl_base64_encode(handle, data, dataLen, &base64);
 271
 272   fprintf(stderr, "%d\n", base64Len);
 273   fprintf(stdout, "%s\n", base64);
 274
 275   free(base64); free(data);
 276 #ifdef CURL_DOES_CONVERSIONS
 277   curl_easy_cleanup(handle);
 278 #endif
 279   return 0;
 280 }
 281 #endif
 282
 283 #ifdef TEST_DECODE
 284 /* decoding test harness. Read in a base64 string from stdin and write out the
 285  * length returned by Curl_base64_decode, followed by the decoded data itself
 286  *
 287  * gcc -DTEST_DECODE base64.c -o base64 mprintf.o memdebug.o
 288  */
 289 #include <stdio.h>
 290
 291 #define TEST_NEED_SUCK
 292 void *suck(int *);
 293
 294 int main(int argc, char **argv, char **envp)
 295 {
 296   char *base64;
 297   int base64Len;
 298   unsigned char *data;
 299   int dataLen;
 300   int i, j;
 301 #ifdef CURL_DOES_CONVERSIONS
 302   /* get a Curl handle so main can translate properly */
 303   struct SessionHandle *handle = curl_easy_init();
 304   if(handle == NULL) {
 305     fprintf(stderr, "Error: curl_easy_init failed\n");
 306     return 0;
 307   }
 308 #endif
 309
 310   base64 = (char *)suck(&base64Len);
 311   dataLen = Curl_base64_decode(base64, &data);
 312
 313   fprintf(stderr, "%d\n", dataLen);
 314
 315   for(i=0; i < dataLen; i+=0x10) {
 316     printf("0x%02x: ", i);
 317     for(j=0; j < 0x10; j++)
 318       if((j+i) < dataLen)
 319         printf("%02x ", data[i+j]);
 320       else
 321         printf("   ");
 322
 323     printf(" | ");
 324
 325     for(j=0; j < 0x10; j++)
 326       if((j+i) < dataLen) {
 327 #ifdef CURL_DOES_CONVERSIONS
 328         if(CURLE_OK !=
 329              Curl_convert_from_network(handle, &data[i+j], (size_t)1))
 330           data[i+j] = '.';
 331 #endif /* CURL_DOES_CONVERSIONS */
 332         printf("%c", ISGRAPH(data[i+j])?data[i+j]:'.');
 333       } else
 334         break;
 335     puts("");
 336   }
 337
 338 #ifdef CURL_DOES_CONVERSIONS
 339   curl_easy_cleanup(handle);
 340 #endif
 341   free(base64); free(data);
 342   return 0;
 343 }
 344 #endif
 345
 346 #ifdef TEST_NEED_SUCK
 347 /* this function 'sucks' in as much as possible from stdin */
 348 void *suck(int *lenptr)
 349 {
 350   int cursize = 8192;
 351   unsigned char *buf = NULL;
 352   int lastread;
 353   int len = 0;
 354
 355   do {
 356     cursize *= 2;
 357     buf = (unsigned char *)realloc(buf, cursize);
 358     memset(buf + len, 0, cursize - len);
 359     lastread = fread(buf + len, 1, cursize - len, stdin);
 360     len += lastread;
 361   } while(!feof(stdin));
 362
 363   lenptr[0] = len;
 364   return (void *)buf;
 365 }
 366 #endif