path: root/camel/gmime-rfc2047.c

/* 
 * gmime-rfc2047.c: implemention of RFC2047
 *
 * Copyright (C) 1999 Bertrand Guiheneuf <Bertrand.Guiheneuf@inria.fr> .
 * 
 * This program is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License as 
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <unicode.h>
#include <string.h>

#include "gmime-rfc2047.h"

#define NOT_RANKED -1

/* This should be changed ASAP to use the base64 code Miguel comitted */

const char *base64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static unsigned char base64_rank[256];
static int base64_rank_table_built;
static void build_base64_rank_table (void);

static int hexval(gchar c) {
  if (isdigit(c)) return c-'0';
  c = tolower(c);
  return c - 'a' + 10;
}

static void decode_quoted(const gchar *text, gchar *to) {
  while (*text) {
    if (*text == '=') {
      gchar a = hexval(text[1]);
      gchar b = hexval(text[2]);
      int c = (a << 4) + b;
      *to = c;
      to++;
      text+=3;
    } else if (*text == '_') {
      *to = ' ';
      to++;
      text++;
    } else {
      *to = *text;
      to++;
      text++;
    }
  }
  *to = 0;
}

static void decode_base64(const gchar *what,  gchar *where) {
  unsigned short pattern = 0;
  int bits = 0;
  int delimiter = '=';
  gchar x;
  gchar *t = where;
  int Q = 0;
  while (*what != delimiter) {
    x = base64_rank[(unsigned char)(*what++)];
    if (x == NOT_RANKED)
      continue;
    pattern <<= 6;
    pattern |= x;
    bits += 6;
    if (bits >= 8) {
      x = (pattern >> (bits - 8)) & 0xff;
      *t++ = x;
      Q++;
      bits -= 8;
    }
  }
  *t = 0;
}

static void
build_base64_rank_table (
    void)
{
    int i;

    if (!base64_rank_table_built) {
        for (i = 0; i < 256; i++)
            base64_rank[i] = NOT_RANKED;
        for (i = 0; i < 64; i++)
            base64_rank[(int) base64_alphabet[i]] = i;
        base64_rank_table_built = 1;
    }
}

gchar *gmime_rfc2047_decode(const gchar *data, const gchar *into_what) {
  gchar buffer[4096] /* FIXME : constant sized buffer */, *b = buffer;

  build_base64_rank_table();

  while (*data) {

    /* If we encounter an error we just break out of the loop and copy the rest
     * of the text as-is */
     
    if (*data=='=') {
      data++;
      if (*data=='?') {
    gchar *charset, *encoding, *text, *end;
    gchar dc[4096];
    charset = data+1;
    encoding = strchr(charset, '?');

    if (!encoding) break;
    encoding++;
        text = strchr(encoding, '?');
    if (!text) break;
    text++;
    end = strstr(text, "?=");
    if (!end) break;
    end++;

    *(encoding-1)=0;
    *(text-1)=0;
    *(end-1)=0;

    if (strcasecmp(encoding, "q")==0) {
      decode_quoted(text, dc);
    } else if (strcasecmp(encoding, "b")==0) {
      decode_base64(text, dc);
    } else {
      /* What to do here? */
      break;
    }

    {
      int f;
      iconv_t i;
      const gchar *d2 = dc;
      int l = strlen(d2), l2 = 4000;

      i = unicode_iconv_open(into_what, charset);
      if (!i) 
         break;
       
      unicode_iconv(i, &d2, &l, &b, &l2);

      unicode_iconv_close(i);
      data = end;
    }
      }
    }
    else {
      *b = *data;
      b++;
    }

    data++;

  }

  while (*data) {
    *b = *data;
    b++;
    data++;
  }

  *b = 0;

  return g_strdup(buffer);
}

gchar *rfc2047_encode(const gchar *string, const gchar *charset) {
  gchar buffer[4096] /* FIXME : constant sized buffer */;
  gchar *b = buffer;
  const gchar *s = string;
  int not_ascii = 0, not_latin1 = 0;
  while (*s) {
    if (*s <= 20 || *s >= 0x7f || *s == '=') { not_ascii = 1; }
    s++;
  }
  
  if (!not_ascii) {
    b += sprintf(b, "%s", string);
  }
  
  else {
    b += sprintf(b, "=?%s?Q?", charset);
    s = string;
    while (*s) {
      if (*s == ' ') b += sprintf(b, "_");
      else if (*s < 0x20 || *s >= 0x7f || *s == '=' || *s == '?' || *s == '_') {
    b += sprintf(b, "=%2x", *s);
      } else {
    b += sprintf(b, "%c", *s);
      }
      s++;
    }
    b += sprintf(b, "?=");
  }

  *b = 0;

  return g_strdup(buffer);
}