#include "Base64.h" #include <string.h>/* DEFINIZIONI PER ENCODINGS */#define MAXLINE  76	 // le funzioni generano righe lunghe 76 caratteri//!< base dati caratteri consentiti per encoding in base64char base64_table[] = {  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  "abcdefghijklmnopqrstuvwxyz"  "0123456789+/"};/*! \struct quoted * base dati caratteri consentiti per encoding/decoding in quoted printable */struct quoted {  const char           *ch;  unsigned short lench;} qp[] = {    {"=00", 3}, {"=01", 3}, {"=02", 3}, {"=03", 3}, {"=04", 3}, {"=05", 3},    {"=06", 3}, {"=07", 3}, {"=08", 3}, {"=09", 3}, {"=0A", 3}, {"=0B", 3},    {"=0C", 3}, {"=0D", 3}, {"=0E", 3}, {"=0F", 3}, {"=10", 3}, {"=11", 3},    {"=12", 3}, {"=13", 3}, {"=14", 3}, {"=15", 3}, {"=16", 3}, {"=17", 3},    {"=18", 3}, {"=19", 3}, {"=1A", 3}, {"=1B", 3}, {"=1C", 3}, {"=1D", 3},    {"=1E", 3}, {"=1F", 3}, {" ",   1}, {"=21", 3}, {"=22", 3}, {"=23", 3},    {"=24", 3}, {"=25", 3}, {"=26", 3}, {"'",   1}, {"(",   1}, {")",   1},    {"=2A", 3}, {"+",   1}, {",",   1}, {"-",   1}, {".",   1}, {"/",   1},    {"0",   1}, {"1",   1}, {"2",   1}, {"3",   1}, {"4",   1}, {"5",   1},    {"6",   1}, {"7",   1}, {"8",   1}, {"9",   1}, {":",   1}, {"=3B", 3},    {"=3C", 3}, {"=3D", 1}, {"=3E", 3}, {"?",   1}, {"=40", 3}, {"A",   1},    {"B",   1}, {"C",   1}, {"D",   1}, {"E",   1}, {"F",   1}, {"G",   1},    {"H",   1}, {"I",   1}, {"J",   1}, {"K",   1}, {"L",   1}, {"M",   1},    {"N",   1}, {"O",   1}, {"P",   1}, {"Q",   1}, {"R",   1}, {"S",   1},    {"T",   1}, {"U",   1}, {"V",   1}, {"W",   1}, {"X",   1}, {"Y",   1},    {"Z",   1}, {"=5B", 3}, {"=5C", 3}, {"=5D", 3}, {"=5E", 3}, {"=5F", 3},    {"=60", 3}, {"a",   1}, {"b",   1}, {"c",   1}, {"d",   1}, {"e",   1},    {"f",   1}, {"g",   1}, {"h",   1}, {"i",   1}, {"j",   1}, {"k",   1},    {"l",   1}, {"m",   1}, {"n",   1}, {"o",   1}, {"p",   1}, {"q",   1},    {"r",   1}, {"s",   1}, {"t",   1}, {"u",   1}, {"v",   1}, {"w",   1},    {"x",   1}, {"y",   1}, {"z",   1}, {"=7B", 3}, {"=7C", 3}, {"=7D", 3},    {"=7E", 3}, {"=7F", 3}, {"=80", 3}, {"=81", 3}, {"=82", 3}, {"=83", 3},    {"=84", 3}, {"=85", 3}, {"=86", 3}, {"=87", 3}, {"=88", 3}, {"=89", 3},    {"=8A", 3}, {"=8B", 3}, {"=8C", 3}, {"=8D", 3}, {"=8E", 3}, {"=8F", 3},    {"=90", 3}, {"=91", 3}, {"=92", 3}, {"=93", 3}, {"=94", 3}, {"=95", 3},    {"=96", 3}, {"=97", 3}, {"=98", 3}, {"=99", 3}, {"=9A", 3}, {"=9B", 3},    {"=9C", 3}, {"=9D", 3}, {"=9E", 3}, {"=9F", 3}, {"=A0", 3}, {"=A1", 3},    {"=A2", 3}, {"=A3", 3}, {"=A4", 3}, {"=A5", 3}, {"=A6", 3}, {"=A7", 3},    {"=A8", 3}, {"=A9", 3}, {"=AA", 3}, {"=AB", 3}, {"=AC", 3}, {"=AD", 3},    {"=AE", 3}, {"=AF", 3}, {"=B0", 3}, {"=B1", 3}, {"=B2", 3}, {"=B3", 3},    {"=B4", 3}, {"=B5", 3}, {"=B6", 3}, {"=B7", 3}, {"=B8", 3}, {"=B9", 3},    {"=BA", 3}, {"=BB", 3}, {"=BC", 3}, {"=BD", 3}, {"=BE", 3}, {"=BF", 3},    {"=C0", 3}, {"=C1", 3}, {"=C2", 3}, {"=C3", 3}, {"=C4", 3}, {"=C5", 3},    {"=C6", 3}, {"=C7", 3}, {"=C8", 3}, {"=C9", 3}, {"=CA", 3}, {"=CB", 3},    {"=CC", 3}, {"=CD", 3}, {"=CE", 3}, {"=CF", 3}, {"=D0", 3}, {"=D1", 3},    {"=D2", 3}, {"=D3", 3}, {"=D4", 3}, {"=D5", 3}, {"=D6", 3}, {"=D7", 3},    {"=D8", 3}, {"=D9", 3}, {"=DA", 3}, {"=DB", 3}, {"=DC", 3}, {"=DD", 3},    {"=DE", 3}, {"=DF", 3}, {"=E0", 3}, {"=E1", 3}, {"=E2", 3}, {"=E3", 3},    {"=E4", 3}, {"=E5", 3}, {"=E6", 3}, {"=E7", 3}, {"=E8", 3}, {"=E9", 3},    {"=EA", 3}, {"=EB", 3}, {"=EC", 3}, {"=ED", 3}, {"=EE", 3}, {"=EF", 3},    {"=F0", 3}, {"=F1", 3}, {"=F2", 3}, {"=F3", 3}, {"=F4", 3}, {"=F5", 3},    {"=F6", 3}, {"=F7", 3}, {"=F8", 3}, {"=F9", 3}, {"=FA", 3}, {"=FB", 3},    {"=FC", 3}, {"=FD", 3}, {"=FE", 3}, {"=FF", 3},};/*! \brief Encoding base64 * * Funzione per l'encoding di una stringa in base64 * * IN: 	  char *dst (puntatore stringa di destinazione), *    	  const char *src (puntatore al dato di origine), *    	  unsigned int len (lunghezza dato di origine) * * RETURN: int (lunghezza stringa di destinazione) */int base64_encode(char *dst, const char *src, unsigned int len){  int x, y = 0, i, flag=0, m=0;  int n = 3;  char triple[3], quad[4], c;   for(x = 0; x < len; x = x + 3){    if((len - x) / 3 == 0)      n = (len - x) % 3;     for(i=0; i < 3; i++)  triple[i] = '0';    for(i=0; i < n; i++)  triple[i] = src[x + i];    quad[0] = base64_table[(triple[0] & 0xFC) >> 2];   // FC = 11111100    quad[1] = base64_table[((triple[0] & 0x03) << 4) | ((triple[1] & 0xF0) >> 4)];  // 03 = 11    quad[2] = base64_table[((triple[1] & 0x0F) << 2) | ((triple[2] & 0xC0) >> 6)];  // 0F = 1111, C0=11110    quad[3] = base64_table[triple[2] & 0x3F];          // 3F = 111111    if(n < 3)  quad[3] = '=';    if(n < 2)  quad[2] = '=';    for(i=0; i < 4; i++)  dst[y + i] = quad[i];    y = y + 4;    m = m + 4; /*   if((m != 0)&&((m % MAXLINE) == 0)){      dst[y] = '\r';      dst[y+1] = '\n';      flag++;      y += 2;      m = 0;    }	*/  }  dst[y] = '\0';  return y;}/*! \brief Decoding base64 - scelta carattere */char decode(char c){  if(c >= 'A' && c <= 'Z')     c = c - 'A';  else    if(c >= 'a' && c <= 'z')     c = c - 'a' + 26;   else    if(c >= '0' && c <= '9')     c = c - '0' + 52;    else      if(c == '+')      c = 62;     else       if(c == '/')      c = 63;       else     c = 0;  return c;}/*! \brief Decoding base64** Funzione per il decoding di un dato in base64** IN: 	  char *dst (puntatore dato di destinazione),*    	  const char *src (puntatore alla stringa origine),*    	  unsigned int len (lunghezza stringa di origine)** RETURN: int (lunghezza dato di destinazione)*/intbase64_decode(char *dst, const char *src, unsigned int len){  int x, y = 0, n, i, flag=0, m=0;  char triple[3];  char quad[4];   for(x = 0; x < (len - m); x = x + 4){      memset(quad, 0, 4);      n = 4;      for(i=0; i < n; i++){        if(src[x + i + m] == '\r')  m += 2;        if(src[x + i + m] == '=')  flag++;        quad[i] = src[x + i + m];      }      quad[0]=decode(quad[0]);      quad[1]=decode(quad[1]);      quad[2]=decode(quad[2]);      quad[3]=decode(quad[3]);      triple[0] = (quad[0] << 2) | (quad[1] >> 4);      triple[1] = ((quad[1] << 4) & 0xF0) | (quad[2] >> 2);   // F0 = 1111 0000      triple[2] = ((quad[2] << 6) & 0xC0) | quad[3];          // C0 = 1100 0000      dst[y] = triple[0];      dst[y+1] = triple[1];      dst[y+2] = triple[2];      y += 3;    }    for(i=0; i <= flag; i++)  dst[y-i] = '\0';   return y - flag;}