+2003-02-25 Jeffrey Stedfast <fejj@ximian.com>
+
+ * camel-mime-message.c: Same as the ones below.
+
+ * camel-mime-part.c: Reverted back to pre-camel-iconv
+
+ * camel-filter-search.c: Same as below.
+
+ * camel-folder-summary.c: Reverted back to pre-camel-iconv
+
+ * camel.c (camel_init): Reverted to pre-camel-iconv
+
+ * camel-charset-map.c (camel_charset_locale_name): Removed (part
+ of the revert).
+ (camel_charset_canonical_name): Same.
+
+ * camel-mime-filter-charset.c: Revert back to using e_iconv from GAL.
+
+ * camel-mime-part-utils.c: Revert back to using e_iconv from GAL.
+
+ * camel-mime-utils.c: Revert back to using e_iconv from GAL.
+
+ * camel-sasl-digest-md5.c: Revert back to using e-iconv from GAL.
+
2003-02-24 Jeffrey Stedfast <fejj@ximian.com>
* camel-charset-map.c (camel_charset_canonical_name): g_alloca
camel-gpg-context.c \
camel-html-parser.c \
camel-http-stream.c \
- camel-iconv.c \
camel-index.c \
camel-internet-address.c \
camel-lock.c \
camel-folder.h \
camel-gpg-context.h \
camel-http-stream.h \
- camel-iconv.h \
camel-index.h \
camel-internet-address.h \
camel-i18n.h \
}
-#ifdef G_THREADS_ENABLED
-static GStaticMutex lock = G_STATIC_MUTEX_INIT;
-#define LOCK() g_static_mutex_lock(&lock)
-#define UNLOCK() g_static_mutex_unlock(&lock)
-#else
-#define LOCK()
-#define UNLOCK()
-#endif
-
-static char *locale_charset = NULL;
-static GHashTable *canon_charsets = NULL;
-
-static void
-canon_charsets_init (int keep)
-{
- char *locale;
-
- LOCK ();
-
- if (canon_charsets != NULL) {
- if (!keep)
- UNLOCK ();
- return;
- }
-
- canon_charsets = g_hash_table_new (g_str_hash, g_str_equal);
-
- locale = setlocale (LC_ALL, NULL);
-
- if (!locale || !strcmp (locale, "C") || !strcmp (locale, "POSIX")) {
- /* The locale "C" or "POSIX" is a portable locale; its
- * LC_CTYPE part corresponds to the 7-bit ASCII character
- * set.
- */
-
- locale_charset = NULL;
- } else {
-#ifdef HAVE_CODESET
- locale_charset = g_strdup (nl_langinfo (CODESET));
- g_ascii_strdown (locale_charset, -1);
-#else
- /* A locale name is typically of the form language[_terri-
- * tory][.codeset][@modifier], where language is an ISO 639
- * language code, territory is an ISO 3166 country code, and
- * codeset is a character set or encoding identifier like
- * ISO-8859-1 or UTF-8.
- */
- char *codeset, *p;
-
- codeset = strchr (locale, '.');
- if (codeset) {
- codeset++;
-
- /* ; is a hack for debian systems and / is a hack for Solaris systems */
- for (p = codeset; *p && !strchr ("@;/", *p); p++)
- ;
- locale_charset = g_strndup (codeset, p - codeset);
- g_ascii_strdown (locale_charset, -1);
- } else {
- /* charset unknown */
- locale_charset = NULL;
- }
-#endif
- }
-
- if (!keep)
- UNLOCK ();
-}
-
-
-/**
- * camel_charset_locale_name:
- *
- * Returns the name of the system's locale charset.
- **/
-const char *
-camel_charset_locale_name (void)
-{
- canon_charsets_init (FALSE);
-
- return locale_charset;
-}
-
-
-/**
- * camel_charset_canonical_name:
- * @charset: charset to canonicalise
- *
- * Returns the charset in its canonical format. This is currently only
- * needed for iso charsets but also handles canonicalisation of
- * windows charsets. May need to expand this to handle canincalisation
- * of more charsets in the future?
- **/
-const char *
-camel_charset_canonical_name (const char *charset)
-{
- char *name, *canon, *tmp;
-
- if (charset == NULL)
- return NULL;
-
- name = g_alloca (strlen (charset) + 1);
- strcpy (name, charset);
- g_ascii_strdown (name, -1);
-
- canon_charsets_init (TRUE);
- canon = g_hash_table_lookup (canon_charsets, name);
- if (canon != NULL) {
- UNLOCK ();
- return canon;
- }
-
- /* Unknown, try canonicalise some basic charset types to something that should work */
- if (strncmp (name, "iso", 3) == 0) {
- /* Convert iso-nnnn-n or isonnnn-n or iso_nnnn-n to iso-nnnn-n or isonnnn-n */
- int iso, codepage;
- char *p;
-
- tmp = name + 3;
- if (*tmp == '-' || *tmp == '_')
- tmp++;
-
- iso = strtoul (tmp, &p, 10);
-
- if (iso == 10646) {
- /* they all become iso-10646 */
- canon = g_strdup ("iso-10646");
- } else {
- /* iso-8859-# */
- tmp = p;
- if (*tmp == '-' || *tmp == '_')
- tmp++;
-
- codepage = strtoul (tmp, &p, 10);
-
- if (p > tmp) {
- /* codepage is numeric */
- canon = g_strdup_printf ("iso-%d-%d", iso, codepage);
- } else {
- /* codepage is a string - probably iso-2022-jp or something */
- canon = g_strdup_printf ("iso-%d-%s", iso, p);
- }
- }
- } else if (strncmp (name, "windows-", 8) == 0) {
- /* Convert windows-#### and windows-cp#### to windows-cp#### */
- tmp = name + 8;
- if (!strncmp (tmp, "cp", 2))
- tmp += 2;
- canon = g_strdup_printf ("windows-cp%s", tmp);
- } else if (strncmp (name, "microsoft-", 10) == 0) {
- /* Convert microsoft-#### or microsoft-cp#### to windows-cp#### */
- tmp = name + 10;
- if (!strncmp (tmp, "cp", 2))
- tmp += 2;
- canon = g_strdup_printf ("windows-cp%s", tmp);
- } else if (strncmp (name, "cp125", 5) == 0) {
- /* Convert cp125# to windows-cp#### */
- canon = g_strdup_printf ("windows-%s", name);
- } else {
- /* Just assume its ok enough as is, case and all */
- canon = g_strdup (charset);
- }
-
- g_hash_table_insert (canon_charsets, g_strdup (name), canon);
- UNLOCK ();
-
- return canon;
-}
-
-
/**
* camel_charset_iso_to_windows:
* @isocharset: a canonicalised ISO charset
void camel_charset_init(CamelCharset *);
void camel_charset_step(CamelCharset *, const char *in, int len);
-const char *camel_charset_locale_name (void);
-const char *camel_charset_canonical_name (const char *charset);
-
const char *camel_charset_best_name (CamelCharset *);
/* helper function */
#include <signal.h>
#include <sys/wait.h>
-#include "e-util/e-sexp.h"
+#include <e-util/e-sexp.h>
+
+#include <gal/util/e-iconv.h>
-#include "camel-charset-map.h"
#include "camel-mime-message.h"
#include "camel-provider.h"
#include "camel-session.h"
ct = camel_mime_part_get_content_type (CAMEL_MIME_PART (message));
if (ct) {
charset = header_content_type_param (ct, "charset");
- charset = camel_charset_canonical_name (charset);
+ charset = e_iconv_charset_name (charset);
}
}
}
#include <errno.h>
#include <stdlib.h>
+#include <gal/util/e-iconv.h>
+
#include "camel-folder-summary.h"
-#include <camel/camel-charset-map.h>
#include <camel/camel-file-utils.h>
#include <camel/camel-mime-filter.h>
#include <camel/camel-mime-filter-index.h>
&& (strcasecmp(charset, "us-ascii") == 0))
charset = NULL;
- charset = camel_charset_canonical_name (charset);
+ charset = charset ? e_iconv_charset_name (charset) : NULL;
subject = summary_format_string(h, "subject", charset);
from = summary_format_address(h, "from");
ci = camel_folder_summary_content_info_new (s);
- charset = camel_charset_locale_name ();
+ charset = e_iconv_locale_charset ();
ci->id = header_msgid_decode (header_raw_find (&h, "content-id", NULL));
ci->description = header_decode_string (header_raw_find (&h, "content-description", NULL), NULL);
ci->encoding = header_content_encoding_decode (header_raw_find (&h, "content-transfer-encoding", NULL));
&& (strcasecmp(charset, "us-ascii") == 0))
charset = NULL;
- charset = camel_charset_canonical_name (charset);
+ charset = charset ? e_iconv_charset_name (charset) : NULL;
subject = summary_format_string(header, "subject", charset);
from = summary_format_address(header, "from");
#include <string.h>
#include <errno.h>
+#include <gal/util/e-iconv.h>
+
#include "camel-mime-filter-charset.h"
#include "camel-charset-map.h"
-#include "camel-iconv.h"
#define d(x)
g_free(f->from);
g_free(f->to);
if (f->ic != (iconv_t) -1) {
- camel_iconv_close (f->ic);
+ e_iconv_close (f->ic);
f->ic = (iconv_t) -1;
}
}
/* what happens with the output bytes if this resets the state? */
if (f->ic != (iconv_t) -1) {
buffer = buf;
- camel_iconv (f->ic, NULL, 0, &buffer, &outlen);
+ e_iconv (f->ic, NULL, 0, &buffer, &outlen);
}
}
if (inleft > 0) {
do {
- converted = camel_iconv (charset->ic, &inbuf, &inleft, &outbuf, &outleft);
+ converted = e_iconv (charset->ic, &inbuf, &inleft, &outbuf, &outleft);
if (converted == (size_t) -1) {
if (errno == E2BIG) {
/*
}
/* flush the iconv conversion */
- camel_iconv (charset->ic, NULL, NULL, &outbuf, &outleft);
+ e_iconv (charset->ic, NULL, NULL, &outbuf, &outleft);
*out = mf->outbuf;
*outlen = mf->outsize - outleft;
inleft = len;
do {
- converted = camel_iconv (charset->ic, &inbuf, &inleft, &outbuf, &outleft);
+ converted = e_iconv (charset->ic, &inbuf, &inleft, &outbuf, &outleft);
if (converted == (size_t) -1) {
if (errno == E2BIG || errno == EINVAL)
break;
new = CAMEL_MIME_FILTER_CHARSET (camel_object_new (camel_mime_filter_charset_get_type ()));
- new->ic = camel_iconv_open (to_charset, from_charset);
+ new->ic = e_iconv_open (to_charset, from_charset);
if (new->ic == (iconv_t) -1) {
g_warning ("Cannot create charset conversion from %s to %s: %s",
from_charset, to_charset, g_strerror (errno));
outptr = check_size (filter, outptr, outend, 16);
- u = camel_utf8_getc_limit(&inptr, inend);
+ u = camel_utf8_getc_limit ((const unsigned char **) &inptr, inend);
switch (u) {
case 0xffff:
g_warning("Truncated utf8 buffer");
#include <string.h>
#include <errno.h>
-#include "camel-charset-map.h"
+#include <gal/util/e-iconv.h>
+
+#include <e-util/e-time-utils.h>
+
#include "camel-mime-message.h"
#include "camel-multipart.h"
#include "camel-stream-mem.h"
#include "camel-mime-filter-charset.h"
#include "camel-mime-filter-bestenc.h"
-#include "e-time-utils.h"
-
#define d(x)
/* these 2 below should be kept in sync */
g_free (message->subject);
if (((CamelMimePart *) message)->content_type) {
charset = header_content_type_param (((CamelMimePart *) message)->content_type, "charset");
- charset = camel_charset_canonical_name (charset);
+ charset = e_iconv_charset_name (charset);
} else
charset = NULL;
message->subject = g_strstrip (header_decode_string (header_value, charset));
#include <stdio.h>
#include <string.h>
#include <unistd.h>
+#include <ctype.h>
#include <errno.h>
-#include <glib/gunicode.h>
+#include <gal/util/e-iconv.h>
#include "string-utils.h"
-#include "camel-iconv.h"
#include "camel-charset-map.h"
#include "camel-mime-part-utils.h"
#include "camel-mime-message.h"
&& (val = camel_html_parser_attr(hp, "content"))
&& (ct = header_content_type_decode(val))) {
charset = header_content_type_param(ct, "charset");
- charset = camel_charset_canonical_name (charset);
+ charset = e_iconv_charset_name (charset);
header_content_type_unref(ct);
}
break;
d(fwrite(in->data, 1, (int)in->len, stdout));
d(printf("\n"));
- cd = camel_iconv_open(to, from);
+ cd = e_iconv_open(to, from);
if (cd == (iconv_t) -1) {
g_warning ("Cannot convert from '%s' to '%s': %s", from, to, strerror (errno));
return NULL;
outbuf = out->data + converted;
outleft = outlen - converted;
- converted = camel_iconv (cd, &inbuf, &inleft, &outbuf, &outleft);
+ converted = e_iconv (cd, &inbuf, &inleft, &outbuf, &outleft);
if (converted == (size_t) -1) {
if (errno != E2BIG && errno != EINVAL)
goto fail;
*/
/* flush the iconv conversion */
- camel_iconv (cd, NULL, NULL, &outbuf, &outleft);
+ e_iconv (cd, NULL, NULL, &outbuf, &outleft);
/* now set the true length on the GByteArray */
converted = outbuf - (char *)out->data;
d(fwrite(out->data, 1, (int)out->len, stdout));
d(printf("\n"));
- camel_iconv_close (cd);
+ e_iconv_close (cd);
return out;
g_byte_array_free (out, TRUE);
- camel_iconv_close (cd);
+ e_iconv_close (cd);
return NULL;
}
ct = camel_mime_parser_content_type (mp);
if (header_content_type_is (ct, "text", "*")) {
charset = header_content_type_param (ct, "charset");
- charset = camel_charset_canonical_name (charset);
+ charset = e_iconv_charset_name (charset);
if (fdec) {
d(printf ("Adding CRLF conversion filter\n"));
* as being in ISO-8859-1 even when in fact they contain funny
* characters from the Windows-CP1252 superset.
*/
+ /* FIXME: not all systems will use the canonical "iso-8859-#" format */
if (!strncasecmp (charset, "iso-8859", 8)) {
/* check for Windows-specific chars... */
if (broken_windows_charset (buffer, charset))
#include <ctype.h>
#include <errno.h>
+#include <gal/util/e-iconv.h>
+
#include "camel-mime-parser.h"
#include "camel-stream-mem.h"
#include "camel-stream-filter.h"
g_free (mime_part->description);
if (mime_part->content_type) {
charset = header_content_type_param (mime_part->content_type, "charset");
- charset = camel_charset_canonical_name (charset);
+ charset = e_iconv_charset_name (charset);
} else
charset = NULL;
mime_part->description = g_strstrip (header_decode_string (header_value, charset));
#include <regex.h>
#include <glib.h>
-#include <glib/gunicode.h>
-#include "e-time-utils.h"
+#include <gal/util/e-iconv.h>
+#include <e-util/e-time-utils.h>
-#include "camel-iconv.h"
#include "camel-mime-utils.h"
#include "camel-charset-map.h"
#include "camel-service.h" /* for camel_gethostbyname() */
d(printf("found ?, encoding is '%c'\n", inptr[0]));
inptr++;
tmplen = inend-inptr-2;
- decword = alloca(tmplen); /* this will always be more-than-enough room */
+ decword = g_alloca (tmplen); /* this will always be more-than-enough room */
switch(toupper(inptr[0])) {
case 'Q':
inlen = quoted_decode(inptr+2, tmplen, decword);
if (inlen > 0) {
/* yuck, all this snot is to setup iconv! */
tmplen = inptr - in - 3;
- encname = alloca (tmplen + 1);
+ encname = g_alloca (tmplen + 1);
memcpy (encname, in + 2, tmplen);
encname[tmplen] = '\0';
if (p)
*p = '\0';
- charset = camel_charset_canonical_name (encname);
+ charset = e_iconv_charset_name (encname);
inbuf = decword;
outlen = inlen * 6 + 16;
- outbase = alloca (outlen);
+ outbase = g_alloca (outlen);
outbuf = outbase;
retry:
- ic = camel_iconv_open ("UTF-8", charset);
+ ic = e_iconv_open ("UTF-8", charset);
if (ic != (iconv_t) -1) {
- ret = camel_iconv (ic, &inbuf, &inlen, &outbuf, &outlen);
+ ret = e_iconv (ic, &inbuf, &inlen, &outbuf, &outlen);
if (ret != (size_t) -1) {
- camel_iconv (ic, NULL, 0, &outbuf, &outlen);
+ e_iconv (ic, NULL, 0, &outbuf, &outlen);
*outbuf = 0;
decoded = g_strdup (outbase);
}
- camel_iconv_close (ic);
+ e_iconv_close (ic);
} else {
w(g_warning ("Cannot decode charset, header display may be corrupt: %s: %s",
charset, strerror (errno)));
if (!retried) {
- charset = camel_charset_locale_name ();
+ charset = e_iconv_locale_charset ();
if (!charset)
charset = "iso-8859-1";
size_t outlen;
iconv_t ic;
- ic = camel_iconv_open ("UTF-8", charset);
+ ic = e_iconv_open ("UTF-8", charset);
if (ic == (iconv_t) -1)
return FALSE;
outlen = inlen * 6 + 16;
outbuf = outbase = g_malloc(outlen);
- if (camel_iconv (ic, &inbuf, &inlen, &outbuf, &outlen) == (size_t) -1) {
+ if (e_iconv (ic, &inbuf, &inlen, &outbuf, &outlen) == (size_t) -1) {
w(g_warning("Conversion to '%s' failed: %s", charset, strerror (errno)));
g_free(outbase);
- camel_iconv_close (ic);
+ e_iconv_close (ic);
return FALSE;
}
*outbuf = 0;
g_string_append(out, outbase);
g_free(outbase);
- camel_iconv_close (ic);
+ e_iconv_close (ic);
return TRUE;
const char *inptr, *inend, *start, *chunk, *locale_charset;
char *dword = NULL;
- locale_charset = camel_charset_locale_name ();
+ locale_charset = e_iconv_locale_charset ();
- out = g_string_new("");
+ out = g_string_new ("");
inptr = in;
inend = inptr + inlen;
chunk = NULL;
/* convert utf8->encoding */
bufflen = len * 6 + 16;
- buffer = alloca (bufflen);
+ buffer = g_alloca (bufflen);
inlen = len;
inptr = in;
- ascii = alloca (bufflen);
+ ascii = g_alloca (bufflen);
if (strcasecmp (type, "UTF-8") != 0)
- ic = camel_iconv_open (type, "UTF-8");
+ ic = e_iconv_open (type, "UTF-8");
while (inlen) {
size_t convlen, proclen;
hopefully-small-enough chunks, and leave it at that */
convlen = MIN(inlen, CAMEL_FOLD_PREENCODED);
p = inptr;
- if (camel_iconv (ic, &inptr, &convlen, &out, &outlen) == (size_t) -1) {
+ if (e_iconv (ic, &inptr, &convlen, &out, &outlen) == (size_t) -1) {
w(g_warning("Conversion problem: conversion truncated: %s", strerror (errno)));
/* blah, we include it anyway, better than infinite loop ... */
inptr = p + convlen;
} else {
/* make sure we flush out any shift state */
- camel_iconv (ic, NULL, 0, &out, &outlen);
+ e_iconv (ic, NULL, 0, &out, &outlen);
}
inlen -= (inptr - p);
}
}
if (ic != (iconv_t) -1)
- camel_iconv_close (ic);
+ e_iconv_close (ic);
}
return NULL;
encoding = g_strndup (in, inptr - in);
- charset = camel_charset_canonical_name (encoding);
+ charset = e_iconv_charset_name (encoding);
g_free (encoding);
inptr = memchr (inptr + 1, '\'', inend - inptr - 1);
inbuf = decword = hex_decode (inptr, inend - inptr);
inlen = strlen (inbuf);
- ic = camel_iconv_open ("UTF-8", charset);
+ ic = e_iconv_open ("UTF-8", charset);
if (ic != (iconv_t) -1) {
size_t ret;
outlen = inlen * 6 + 16;
outbuf = outbase = g_malloc (outlen);
- ret = camel_iconv (ic, &inbuf, &inlen, &outbuf, &outlen);
+ ret = e_iconv (ic, &inbuf, &inlen, &outbuf, &outlen);
if (ret != (size_t) -1) {
- camel_iconv (ic, NULL, 0, &outbuf, &outlen);
+ e_iconv (ic, NULL, 0, &outbuf, &outlen);
*outbuf = '\0';
g_free (decoded);
decoded = outbase;
}
- camel_iconv_close (ic);
+ e_iconv_close (ic);
} else {
decoded = decword;
}
inbuf = value;
inlen = strlen (inbuf);
- charset = camel_charset_locale_name ();
- ic = camel_iconv_open ("UTF-8", charset ? charset : "ISO-8859-1");
+ charset = e_iconv_locale_charset ();
+ ic = e_iconv_open ("UTF-8", charset ? charset : "ISO-8859-1");
if (ic != (iconv_t) -1) {
size_t ret;
outlen = inlen * 6 + 16;
outbuf = outbase = g_malloc (outlen);
- ret = camel_iconv (ic, &inbuf, &inlen, &outbuf, &outlen);
+ ret = e_iconv (ic, &inbuf, &inlen, &outbuf, &outlen);
if (ret != (size_t) -1) {
- camel_iconv (ic, NULL, 0, &outbuf, &outlen);
+ e_iconv (ic, NULL, 0, &outbuf, &outlen);
*outbuf = '\0';
}
- camel_iconv_close (ic);
+ e_iconv_close (ic);
g_free (value);
value = outbase;
charset = "iso-8859-1";
if (strcasecmp (charset, "UTF-8") != 0)
- cd = camel_iconv_open (charset, "UTF-8");
+ cd = e_iconv_open (charset, "UTF-8");
if (cd == (iconv_t) -1) {
charset = "UTF-8";
outptr = outbuf = g_malloc (outleft);
inbuf = in;
- if (camel_iconv (cd, &inbuf, &inleft, &outptr, &outleft) == (size_t) -1) {
+ if (e_iconv (cd, &inbuf, &inleft, &outptr, &outleft) == (size_t) -1) {
w(g_warning ("Conversion problem: conversion truncated: %s", strerror (errno)));
} else {
- camel_iconv (cd, NULL, 0, &outptr, &outleft);
+ e_iconv (cd, NULL, 0, &outptr, &outleft);
}
- camel_iconv_close (cd);
+ e_iconv_close (cd);
inptr = outbuf;
inend = outptr;
printf("Invalid header line: '%s'\n", header);
return;
}
- name = alloca(fieldlen+1);
+ name = g_alloca (fieldlen + 1);
memcpy(name, header, fieldlen);
name[fieldlen] = 0;
/*
* Authors: Jeffrey Stedfast <fejj@ximian.com>
*
- * Copyright 2001 Ximian, Inc. (www.ximian.com)
+ * Copyright 2001-2003 Ximian, Inc. (www.ximian.com)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
*
*/
+
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <e-util/md5-utils.h>
-#include "camel-iconv.h"
+#include <gal/util/e-iconv.h>
+
#include "camel-charset-map.h"
#include "camel-mime-utils.h"
#include "camel-sasl-digest-md5.h"
const char *inbuf;
iconv_t cd;
- charset = camel_charset_locale_name ();
+ charset = e_iconv_locale_charset ();
if (!charset)
charset = "iso-8859-1";
- cd = camel_iconv_open (resp->charset, charset);
+ cd = e_iconv_open (resp->charset, charset);
len = strlen (resp->username);
outlen = 2 * len; /* plenty of space */
outbuf = username = g_malloc0 (outlen + 1);
inbuf = resp->username;
- if (cd == (iconv_t) -1 || camel_iconv (cd, &inbuf, &len, &outbuf, &outlen) == (size_t) -1) {
+ if (cd == (iconv_t) -1 || e_iconv (cd, &inbuf, &len, &outbuf, &outlen) == (size_t) -1) {
/* We can't convert to UTF-8 - pretend we never got a charset param? */
g_free (resp->charset);
resp->charset = NULL;
}
if (cd != (iconv_t) -1)
- camel_iconv_close (cd);
+ e_iconv_close (cd);
g_byte_array_append (buffer, username, strlen (username));
g_free (username);
void camel_utf8_putc(unsigned char **ptr, guint32 c);
guint32 camel_utf8_getc(const unsigned char **ptr);
+guint32 camel_utf8_getc_limit (const unsigned char **ptr, const unsigned char *end);
/* utility func for utf8 gstrings */
void g_string_append_u(GString *out, guint32 c);
char *camel_utf7_utf8(const char *ptr);
char *camel_utf8_utf7(const char *ptr);
-
#endif /* ! _CAMEL_UTF8_H */
camel_certdb_save (certdb);
camel_object_unref (certdb);
}
-
- camel_iconv_shutdown ();
}
gint
/* initialise global camel_object_type */
camel_object_get_type();
- camel_iconv_init ();
-
camel_mime_utils_init ();
#ifdef HAVE_NSS
projects / platform / upstream / evolution-data-server.git / commitdiff