aboutsummaryrefslogtreecommitdiff
path: root/libsylph
diff options
context:
space:
mode:
Diffstat (limited to 'libsylph')
-rw-r--r--libsylph/Makefile.am25
-rw-r--r--libsylph/base64.c168
-rw-r--r--libsylph/base64.h46
-rw-r--r--libsylph/codeconv.c1982
-rw-r--r--libsylph/codeconv.h239
-rw-r--r--libsylph/defs.h122
-rw-r--r--libsylph/prefs.c465
-rw-r--r--libsylph/prefs.h80
-rw-r--r--libsylph/quoted-printable.c232
-rw-r--r--libsylph/quoted-printable.h36
-rw-r--r--libsylph/session.c793
-rw-r--r--libsylph/session.h205
-rw-r--r--libsylph/socket.c1397
-rw-r--r--libsylph/socket.h124
-rw-r--r--libsylph/ssl.c175
-rw-r--r--libsylph/ssl.h58
-rw-r--r--libsylph/stringtable.c163
-rw-r--r--libsylph/stringtable.h38
-rw-r--r--libsylph/unmime.c134
-rw-r--r--libsylph/unmime.h27
-rw-r--r--libsylph/utils.c3436
-rw-r--r--libsylph/utils.h493
-rw-r--r--libsylph/uuencode.c101
-rw-r--r--libsylph/uuencode.h24
-rw-r--r--libsylph/xml.c655
-rw-r--r--libsylph/xml.h108
26 files changed, 11326 insertions, 0 deletions
diff --git a/libsylph/Makefile.am b/libsylph/Makefile.am
new file mode 100644
index 00000000..bb2eec32
--- /dev/null
+++ b/libsylph/Makefile.am
@@ -0,0 +1,25 @@
+
+AM_CPPFLAGS = -DG_LOG_DOMAIN=\"LibSylph\"
+
+INCLUDES = $(GLIB_CFLAGS) -I$(top_srcdir) -I$(includedir)
+
+#lib_LTLIBRARIES = libsylph.la
+noinst_LTLIBRARIES = libsylph.la
+
+libsylph_la_SOURCES = \
+ defs.h \
+ base64.c base64.h \
+ codeconv.c codeconv.h \
+ prefs.c prefs.h \
+ quoted-printable.c quoted-printable.h \
+ session.c session.h \
+ socket.c socket.h \
+ ssl.c ssl.h \
+ stringtable.c stringtable.h \
+ unmime.c unmime.h \
+ utils.c utils.h \
+ uuencode.c uuencode.h \
+ xml.c xml.h
+
+libsylph_la_LDFLAGS =
+libsylph_la_LIBADD = $(GLIB_LIBS)
diff --git a/libsylph/base64.c b/libsylph/base64.c
new file mode 100644
index 00000000..484cd286
--- /dev/null
+++ b/libsylph/base64.c
@@ -0,0 +1,168 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2002 Hiroyuki Yamamoto
+ *
+ * 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 <glib.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "base64.h"
+
+static const gchar base64char[64] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static const gchar base64val[128] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
+};
+
+#define BASE64VAL(c) (isascii((guchar)c) ? base64val[(gint)(c)] : -1)
+
+void base64_encode(gchar *out, const guchar *in, gint inlen)
+{
+ const guchar *inp = in;
+ gchar *outp = out;
+
+ while (inlen >= 3) {
+ *outp++ = base64char[(inp[0] >> 2) & 0x3f];
+ *outp++ = base64char[((inp[0] & 0x03) << 4) |
+ ((inp[1] >> 4) & 0x0f)];
+ *outp++ = base64char[((inp[1] & 0x0f) << 2) |
+ ((inp[2] >> 6) & 0x03)];
+ *outp++ = base64char[inp[2] & 0x3f];
+
+ inp += 3;
+ inlen -= 3;
+ }
+
+ if (inlen > 0) {
+ *outp++ = base64char[(inp[0] >> 2) & 0x3f];
+ if (inlen == 1) {
+ *outp++ = base64char[(inp[0] & 0x03) << 4];
+ *outp++ = '=';
+ } else {
+ *outp++ = base64char[((inp[0] & 0x03) << 4) |
+ ((inp[1] >> 4) & 0x0f)];
+ *outp++ = base64char[((inp[1] & 0x0f) << 2)];
+ }
+ *outp++ = '=';
+ }
+
+ *outp = '\0';
+}
+
+gint base64_decode(guchar *out, const gchar *in, gint inlen)
+{
+ const gchar *inp = in;
+ guchar *outp = out;
+ gchar buf[4];
+
+ if (inlen < 0)
+ inlen = G_MAXINT;
+
+ while (inlen >= 4 && *inp != '\0') {
+ buf[0] = *inp++;
+ inlen--;
+ if (BASE64VAL(buf[0]) == -1) break;
+
+ buf[1] = *inp++;
+ inlen--;
+ if (BASE64VAL(buf[1]) == -1) break;
+
+ buf[2] = *inp++;
+ inlen--;
+ if (buf[2] != '=' && BASE64VAL(buf[2]) == -1) break;
+
+ buf[3] = *inp++;
+ inlen--;
+ if (buf[3] != '=' && BASE64VAL(buf[3]) == -1) break;
+
+ *outp++ = ((BASE64VAL(buf[0]) << 2) & 0xfc) |
+ ((BASE64VAL(buf[1]) >> 4) & 0x03);
+ if (buf[2] != '=') {
+ *outp++ = ((BASE64VAL(buf[1]) & 0x0f) << 4) |
+ ((BASE64VAL(buf[2]) >> 2) & 0x0f);
+ if (buf[3] != '=') {
+ *outp++ = ((BASE64VAL(buf[2]) & 0x03) << 6) |
+ (BASE64VAL(buf[3]) & 0x3f);
+ }
+ }
+ }
+
+ return outp - out;
+}
+
+Base64Decoder *base64_decoder_new(void)
+{
+ Base64Decoder *decoder;
+
+ decoder = g_new0(Base64Decoder, 1);
+ return decoder;
+}
+
+void base64_decoder_free(Base64Decoder *decoder)
+{
+ g_free(decoder);
+}
+
+gint base64_decoder_decode(Base64Decoder *decoder,
+ const gchar *in, guchar *out)
+{
+ gint len, total_len = 0;
+ gint buf_len;
+ gchar buf[4];
+
+ g_return_val_if_fail(decoder != NULL, -1);
+ g_return_val_if_fail(in != NULL, -1);
+ g_return_val_if_fail(out != NULL, -1);
+
+ buf_len = decoder->buf_len;
+ memcpy(buf, decoder->buf, sizeof(buf));
+
+ for (;;) {
+ while (buf_len < 4) {
+ gchar c = *in;
+
+ in++;
+ if (c == '\0') break;
+ if (c == '\r' || c == '\n') continue;
+ if (c != '=' && BASE64VAL(c) == -1)
+ return -1;
+ buf[buf_len++] = c;
+ }
+ if (buf_len < 4 || buf[0] == '=' || buf[1] == '=') {
+ decoder->buf_len = buf_len;
+ memcpy(decoder->buf, buf, sizeof(buf));
+ return total_len;
+ }
+ len = base64_decode(out, buf, 4);
+ out += len;
+ total_len += len;
+ buf_len = 0;
+ if (len < 3) {
+ decoder->buf_len = 0;
+ return total_len;
+ }
+ }
+}
diff --git a/libsylph/base64.h b/libsylph/base64.h
new file mode 100644
index 00000000..4aa55758
--- /dev/null
+++ b/libsylph/base64.h
@@ -0,0 +1,46 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2002 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __BASE64_H__
+#define __BASE64_H__
+
+#include <glib.h>
+
+typedef struct _Base64Decoder Base64Decoder;
+
+struct _Base64Decoder
+{
+ gint buf_len;
+ gchar buf[4];
+};
+
+void base64_encode (gchar *out,
+ const guchar *in,
+ gint inlen);
+gint base64_decode (guchar *out,
+ const gchar *in,
+ gint inlen);
+
+Base64Decoder *base64_decoder_new (void);
+void base64_decoder_free (Base64Decoder *decoder);
+gint base64_decoder_decode (Base64Decoder *decoder,
+ const gchar *in,
+ guchar *out);
+
+#endif /* __BASE64_H__ */
diff --git a/libsylph/codeconv.c b/libsylph/codeconv.c
new file mode 100644
index 00000000..c88b588c
--- /dev/null
+++ b/libsylph/codeconv.c
@@ -0,0 +1,1982 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "defs.h"
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#if HAVE_LOCALE_H
+# include <locale.h>
+#endif
+
+#include <iconv.h>
+
+#include "codeconv.h"
+#include "unmime.h"
+#include "base64.h"
+#include "quoted-printable.h"
+#include "utils.h"
+
+typedef enum
+{
+ JIS_ASCII,
+ JIS_KANJI,
+ JIS_HWKANA,
+ JIS_AUXKANJI
+} JISState;
+
+#define SUBST_CHAR '_'
+#define ESC '\033'
+
+#define iseuckanji(c) \
+ (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xfe)
+#define iseuchwkana1(c) \
+ (((c) & 0xff) == 0x8e)
+#define iseuchwkana2(c) \
+ (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xdf)
+#define iseucaux(c) \
+ (((c) & 0xff) == 0x8f)
+#define issjiskanji1(c) \
+ ((((c) & 0xff) >= 0x81 && ((c) & 0xff) <= 0x9f) || \
+ (((c) & 0xff) >= 0xe0 && ((c) & 0xff) <= 0xfc))
+#define issjiskanji2(c) \
+ ((((c) & 0xff) >= 0x40 && ((c) & 0xff) <= 0x7e) || \
+ (((c) & 0xff) >= 0x80 && ((c) & 0xff) <= 0xfc))
+#define issjishwkana(c) \
+ (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xdf)
+
+#define K_IN() \
+ if (state != JIS_KANJI) { \
+ *out++ = ESC; \
+ *out++ = '$'; \
+ *out++ = 'B'; \
+ state = JIS_KANJI; \
+ }
+
+#define K_OUT() \
+ if (state != JIS_ASCII) { \
+ *out++ = ESC; \
+ *out++ = '('; \
+ *out++ = 'B'; \
+ state = JIS_ASCII; \
+ }
+
+#define HW_IN() \
+ if (state != JIS_HWKANA) { \
+ *out++ = ESC; \
+ *out++ = '('; \
+ *out++ = 'I'; \
+ state = JIS_HWKANA; \
+ }
+
+#define AUX_IN() \
+ if (state != JIS_AUXKANJI) { \
+ *out++ = ESC; \
+ *out++ = '$'; \
+ *out++ = '('; \
+ *out++ = 'D'; \
+ state = JIS_AUXKANJI; \
+ }
+
+static gchar *conv_jistoeuc(const gchar *inbuf, gint *error);
+static gchar *conv_euctojis(const gchar *inbuf, gint *error);
+static gchar *conv_sjistoeuc(const gchar *inbuf, gint *error);
+
+static gchar *conv_jistoutf8(const gchar *inbuf, gint *error);
+static gchar *conv_sjistoutf8(const gchar *inbuf, gint *error);
+static gchar *conv_euctoutf8(const gchar *inbuf, gint *error);
+static gchar *conv_anytoutf8(const gchar *inbuf, gint *error);
+
+static gchar *conv_utf8toeuc(const gchar *inbuf, gint *error);
+static gchar *conv_utf8tojis(const gchar *inbuf, gint *error);
+
+/* static void conv_unreadable_eucjp(gchar *str); */
+static void conv_unreadable_8bit(gchar *str);
+/* static void conv_unreadable_latin(gchar *str); */
+
+static gchar *conv_jistodisp(const gchar *inbuf, gint *error);
+static gchar *conv_sjistodisp(const gchar *inbuf, gint *error);
+static gchar *conv_euctodisp(const gchar *inbuf, gint *error);
+
+static gchar *conv_anytodisp(const gchar *inbuf, gint *error);
+static gchar *conv_ustodisp(const gchar *inbuf, gint *error);
+static gchar *conv_noconv(const gchar *inbuf, gint *error);
+
+static gchar *conv_jistoeuc(const gchar *inbuf, gint *error)
+{
+ gchar *outbuf;
+ const guchar *in = (guchar *)inbuf;
+ guchar *out;
+ JISState state = JIS_ASCII;
+ gint error_ = 0;
+
+ outbuf = g_malloc(strlen(inbuf) * 2 + 1);
+ out = (guchar *)outbuf;
+
+ while (*in != '\0') {
+ if (*in == ESC) {
+ in++;
+ if (*in == '$') {
+ if (*(in + 1) == '@' || *(in + 1) == 'B') {
+ state = JIS_KANJI;
+ in += 2;
+ } else if (*(in + 1) == '(' &&
+ *(in + 2) == 'D') {
+ state = JIS_AUXKANJI;
+ in += 3;
+ } else {
+ /* unknown escape sequence */
+ error_ = -1;
+ state = JIS_ASCII;
+ }
+ } else if (*in == '(') {
+ if (*(in + 1) == 'B' || *(in + 1) == 'J') {
+ state = JIS_ASCII;
+ in += 2;
+ } else if (*(in + 1) == 'I') {
+ state = JIS_HWKANA;
+ in += 2;
+ } else {
+ /* unknown escape sequence */
+ error_ = -1;
+ state = JIS_ASCII;
+ }
+ } else {
+ /* unknown escape sequence */
+ error_ = -1;
+ state = JIS_ASCII;
+ }
+ } else if (*in == 0x0e) {
+ state = JIS_HWKANA;
+ in++;
+ } else if (*in == 0x0f) {
+ state = JIS_ASCII;
+ in++;
+ } else {
+ switch (state) {
+ case JIS_ASCII:
+ *out++ = *in++;
+ break;
+ case JIS_KANJI:
+ *out++ = *in++ | 0x80;
+ if (*in == '\0') break;
+ *out++ = *in++ | 0x80;
+ break;
+ case JIS_HWKANA:
+ *out++ = 0x8e;
+ *out++ = *in++ | 0x80;
+ break;
+ case JIS_AUXKANJI:
+ *out++ = 0x8f;
+ *out++ = *in++ | 0x80;
+ if (*in == '\0') break;
+ *out++ = *in++ | 0x80;
+ break;
+ }
+ }
+ }
+
+ *out = '\0';
+
+ if (error)
+ *error = error_;
+
+ return outbuf;
+}
+
+#define JIS_HWDAKUTEN 0x5e
+#define JIS_HWHANDAKUTEN 0x5f
+
+static gint conv_jis_hantozen(guchar *outbuf, guchar jis_code, guchar sound_sym)
+{
+ static guint16 h2z_tbl[] = {
+ /* 0x20 - 0x2f */
+ 0x0000, 0x2123, 0x2156, 0x2157, 0x2122, 0x2126, 0x2572, 0x2521,
+ 0x2523, 0x2525, 0x2527, 0x2529, 0x2563, 0x2565, 0x2567, 0x2543,
+ /* 0x30 - 0x3f */
+ 0x213c, 0x2522, 0x2524, 0x2526, 0x2528, 0x252a, 0x252b, 0x252d,
+ 0x252f, 0x2531, 0x2533, 0x2535, 0x2537, 0x2539, 0x253b, 0x253d,
+ /* 0x40 - 0x4f */
+ 0x253f, 0x2541, 0x2544, 0x2546, 0x2548, 0x254a, 0x254b, 0x254c,
+ 0x254d, 0x254e, 0x254f, 0x2552, 0x2555, 0x2558, 0x255b, 0x255e,
+ /* 0x50 - 0x5f */
+ 0x255f, 0x2560, 0x2561, 0x2562, 0x2564, 0x2566, 0x2568, 0x2569,
+ 0x256a, 0x256b, 0x256c, 0x256d, 0x256f, 0x2573, 0x212b, 0x212c
+ };
+
+ static guint16 dakuten_tbl[] = {
+ /* 0x30 - 0x3f */
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x252c, 0x252e,
+ 0x2530, 0x2532, 0x2534, 0x2536, 0x2538, 0x253a, 0x253c, 0x253e,
+ /* 0x40 - 0x4f */
+ 0x2540, 0x2542, 0x2545, 0x2547, 0x2549, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x2550, 0x2553, 0x2556, 0x2559, 0x255c, 0x0000
+ };
+
+ static guint16 handakuten_tbl[] = {
+ /* 0x4a - 0x4e */
+ 0x2551, 0x2554, 0x2557, 0x255a, 0x255d
+ };
+
+ guint16 out_code;
+
+ jis_code &= 0x7f;
+ sound_sym &= 0x7f;
+
+ if (jis_code < 0x21 || jis_code > 0x5f)
+ return 0;
+
+ if (sound_sym == JIS_HWDAKUTEN &&
+ jis_code >= 0x36 && jis_code <= 0x4e) {
+ out_code = dakuten_tbl[jis_code - 0x30];
+ if (out_code != 0) {
+ *outbuf = out_code >> 8;
+ *(outbuf + 1) = out_code & 0xff;
+ return 2;
+ }
+ }
+
+ if (sound_sym == JIS_HWHANDAKUTEN &&
+ jis_code >= 0x4a && jis_code <= 0x4e) {
+ out_code = handakuten_tbl[jis_code - 0x4a];
+ *outbuf = out_code >> 8;
+ *(outbuf + 1) = out_code & 0xff;
+ return 2;
+ }
+
+ out_code = h2z_tbl[jis_code - 0x20];
+ *outbuf = out_code >> 8;
+ *(outbuf + 1) = out_code & 0xff;
+ return 1;
+}
+
+static gchar *conv_euctojis(const gchar *inbuf, gint *error)
+{
+ gchar *outbuf;
+ const guchar *in = (guchar *)inbuf;
+ guchar *out;
+ JISState state = JIS_ASCII;
+ gint error_ = 0;
+
+ outbuf = g_malloc(strlen(inbuf) * 3 + 4);
+ out = (guchar *)outbuf;
+
+ while (*in != '\0') {
+ if (isascii(*in)) {
+ K_OUT();
+ *out++ = *in++;
+ } else if (iseuckanji(*in)) {
+ if (iseuckanji(*(in + 1))) {
+ K_IN();
+ *out++ = *in++ & 0x7f;
+ *out++ = *in++ & 0x7f;
+ } else {
+ error_ = -1;
+ K_OUT();
+ *out++ = SUBST_CHAR;
+ in++;
+ if (*in != '\0' && !isascii(*in)) {
+ *out++ = SUBST_CHAR;
+ in++;
+ }
+ }
+ } else if (iseuchwkana1(*in)) {
+ if (iseuchwkana2(*(in + 1))) {
+ //if (prefs_common.allow_jisx0201_kana) {
+ if (0) {
+ HW_IN();
+ in++;
+ *out++ = *in++ & 0x7f;
+ } else {
+ guchar jis_ch[2];
+ gint len;
+
+ if (iseuchwkana1(*(in + 2)) &&
+ iseuchwkana2(*(in + 3)))
+ len = conv_jis_hantozen
+ (jis_ch,
+ *(in + 1), *(in + 3));
+ else
+ len = conv_jis_hantozen
+ (jis_ch,
+ *(in + 1), '\0');
+ if (len == 0)
+ in += 2;
+ else {
+ K_IN();
+ in += len * 2;
+ *out++ = jis_ch[0];
+ *out++ = jis_ch[1];
+ }
+ }
+ } else {
+ error_ = -1;
+ K_OUT();
+ in++;
+ if (*in != '\0' && !isascii(*in)) {
+ *out++ = SUBST_CHAR;
+ in++;
+ }
+ }
+ } else if (iseucaux(*in)) {
+ in++;
+ if (iseuckanji(*in) && iseuckanji(*(in + 1))) {
+ AUX_IN();
+ *out++ = *in++ & 0x7f;
+ *out++ = *in++ & 0x7f;
+ } else {
+ error_ = -1;
+ K_OUT();
+ if (*in != '\0' && !isascii(*in)) {
+ *out++ = SUBST_CHAR;
+ in++;
+ if (*in != '\0' && !isascii(*in)) {
+ *out++ = SUBST_CHAR;
+ in++;
+ }
+ }
+ }
+ } else {
+ error_ = -1;
+ K_OUT();
+ *out++ = SUBST_CHAR;
+ in++;
+ }
+ }
+
+ K_OUT();
+ *out = '\0';
+
+ if (error)
+ *error = error_;
+
+ return outbuf;
+}
+
+static gchar *conv_sjistoeuc(const gchar *inbuf, gint *error)
+{
+ gchar *outbuf;
+ const guchar *in = (guchar *)inbuf;
+ guchar *out;
+ gint error_ = 0;
+
+ outbuf = g_malloc(strlen(inbuf) * 2 + 1);
+ out = (guchar *)outbuf;
+
+ while (*in != '\0') {
+ if (isascii(*in)) {
+ *out++ = *in++;
+ } else if (issjiskanji1(*in)) {
+ if (issjiskanji2(*(in + 1))) {
+ guchar out1 = *in;
+ guchar out2 = *(in + 1);
+ guchar row;
+
+ row = out1 < 0xa0 ? 0x70 : 0xb0;
+ if (out2 < 0x9f) {
+ out1 = (out1 - row) * 2 - 1;
+ out2 -= out2 > 0x7f ? 0x20 : 0x1f;
+ } else {
+ out1 = (out1 - row) * 2;
+ out2 -= 0x7e;
+ }
+
+ *out++ = out1 | 0x80;
+ *out++ = out2 | 0x80;
+ in += 2;
+ } else {
+ error_ = -1;
+ *out++ = SUBST_CHAR;
+ in++;
+ if (*in != '\0' && !isascii(*in)) {
+ *out++ = SUBST_CHAR;
+ in++;
+ }
+ }
+ } else if (issjishwkana(*in)) {
+ *out++ = 0x8e;
+ *out++ = *in++;
+ } else {
+ error_ = -1;
+ *out++ = SUBST_CHAR;
+ in++;
+ }
+ }
+
+ *out = '\0';
+
+ if (error)
+ *error = error_;
+
+ return outbuf;
+}
+
+static gchar *conv_jistoutf8(const gchar *inbuf, gint *error)
+{
+ gchar *eucstr, *utf8str;
+ gint e_error = 0, u_error = 0;
+
+ eucstr = conv_jistoeuc(inbuf, &e_error);
+ utf8str = conv_euctoutf8(eucstr, &u_error);
+ g_free(eucstr);
+
+ if (error)
+ *error = (e_error | u_error);
+
+ return utf8str;
+}
+
+static gchar *conv_sjistoutf8(const gchar *inbuf, gint *error)
+{
+ gchar *utf8str;
+
+ utf8str = conv_iconv_strdup(inbuf, CS_SHIFT_JIS, CS_UTF_8, error);
+ if (!utf8str)
+ utf8str = g_strdup(inbuf);
+
+ return utf8str;
+}
+
+static gchar *conv_euctoutf8(const gchar *inbuf, gint *error)
+{
+ static iconv_t cd = (iconv_t)-1;
+ static gboolean iconv_ok = TRUE;
+
+ if (cd == (iconv_t)-1) {
+ if (!iconv_ok) {
+ if (error)
+ *error = -1;
+ return g_strdup(inbuf);
+ }
+
+ cd = iconv_open(CS_UTF_8, CS_EUC_JP_MS);
+ if (cd == (iconv_t)-1) {
+ cd = iconv_open(CS_UTF_8, CS_EUC_JP);
+ if (cd == (iconv_t)-1) {
+ g_warning("conv_euctoutf8(): %s\n",
+ g_strerror(errno));
+ iconv_ok = FALSE;
+ if (error)
+ *error = -1;
+ return g_strdup(inbuf);
+ }
+ }
+ }
+
+ return conv_iconv_strdup_with_cd(inbuf, cd, error);
+}
+
+static gchar *conv_anytoutf8(const gchar *inbuf, gint *error)
+{
+ switch (conv_guess_ja_encoding(inbuf)) {
+ case C_ISO_2022_JP:
+ return conv_jistoutf8(inbuf, error);
+ case C_SHIFT_JIS:
+ return conv_sjistoutf8(inbuf, error);
+ case C_EUC_JP:
+ return conv_euctoutf8(inbuf, error);
+ default:
+ if (error)
+ *error = 0;
+ return g_strdup(inbuf);
+ }
+}
+
+static gchar *conv_utf8toeuc(const gchar *inbuf, gint *error)
+{
+ static iconv_t cd = (iconv_t)-1;
+ static gboolean iconv_ok = TRUE;
+
+ if (cd == (iconv_t)-1) {
+ if (!iconv_ok) {
+ if (error)
+ *error = -1;
+ return g_strdup(inbuf);
+ }
+
+ cd = iconv_open(CS_EUC_JP_MS, CS_UTF_8);
+ if (cd == (iconv_t)-1) {
+ cd = iconv_open(CS_EUC_JP, CS_UTF_8);
+ if (cd == (iconv_t)-1) {
+ g_warning("conv_utf8toeuc(): %s\n",
+ g_strerror(errno));
+ iconv_ok = FALSE;
+ if (error)
+ *error = -1;
+ return g_strdup(inbuf);
+ }
+ }
+ }
+
+ return conv_iconv_strdup_with_cd(inbuf, cd, error);
+}
+
+static gchar *conv_utf8tojis(const gchar *inbuf, gint *error)
+{
+ gchar *eucstr, *jisstr;
+ gint e_error = 0, j_error = 0;
+
+ eucstr = conv_utf8toeuc(inbuf, &e_error);
+ jisstr = conv_euctojis(eucstr, &j_error);
+ g_free(eucstr);
+
+ if (error)
+ *error = (e_error | j_error);
+
+ return jisstr;
+}
+
+#if 0
+static gchar valid_eucjp_tbl[][96] = {
+ /* 0xa2a0 - 0xa2ff */
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0 },
+
+ /* 0xa3a0 - 0xa3ff */
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 },
+
+ /* 0xa4a0 - 0xa4ff */
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+
+ /* 0xa5a0 - 0xa5ff */
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+
+ /* 0xa6a0 - 0xa6ff */
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+
+ /* 0xa7a0 - 0xa7ff */
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+
+ /* 0xa8a0 - 0xa8ff */
+ { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+};
+
+static gboolean isprintableeuckanji(guchar c1, guchar c2)
+{
+ if (c1 <= 0xa0 || c1 >= 0xf5)
+ return FALSE;
+ if (c2 <= 0xa0 || c2 == 0xff)
+ return FALSE;
+
+ if (c1 >= 0xa9 && c1 <= 0xaf)
+ return FALSE;
+
+ if (c1 >= 0xa2 && c1 <= 0xa8)
+ return (gboolean)valid_eucjp_tbl[c1 - 0xa2][c2 - 0xa0];
+
+ if (c1 == 0xcf) {
+ if (c2 >= 0xd4 && c2 <= 0xfe)
+ return FALSE;
+ } else if (c1 == 0xf4) {
+ if (c2 >= 0xa7 && c2 <= 0xfe)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void conv_unreadable_eucjp(gchar *str)
+{
+ register guchar *p = str;
+
+ while (*p != '\0') {
+ if (isascii(*p)) {
+ /* convert CR+LF -> LF */
+ if (*p == '\r' && *(p + 1) == '\n')
+ memmove(p, p + 1, strlen(p));
+ /* printable 7 bit code */
+ p++;
+ } else if (iseuckanji(*p)) {
+ if (isprintableeuckanji(*p, *(p + 1))) {
+ /* printable euc-jp code */
+ p += 2;
+ } else {
+ /* substitute unprintable code */
+ *p++ = SUBST_CHAR;
+ if (*p != '\0') {
+ if (isascii(*p))
+ p++;
+ else
+ *p++ = SUBST_CHAR;
+ }
+ }
+ } else if (iseuchwkana1(*p)) {
+ if (iseuchwkana2(*(p + 1)))
+ /* euc-jp hankaku kana */
+ p += 2;
+ else
+ *p++ = SUBST_CHAR;
+ } else if (iseucaux(*p)) {
+ if (iseuckanji(*(p + 1)) && iseuckanji(*(p + 2))) {
+ /* auxiliary kanji */
+ p += 3;
+ } else
+ *p++ = SUBST_CHAR;
+ } else
+ /* substitute unprintable 1 byte code */
+ *p++ = SUBST_CHAR;
+ }
+}
+#endif
+
+static void conv_unreadable_8bit(gchar *str)
+{
+ register gchar *p = str;
+
+ while (*p != '\0') {
+ /* convert CR+LF -> LF */
+ if (*p == '\r' && *(p + 1) == '\n')
+ memmove(p, p + 1, strlen(p));
+ else if (!isascii(*(guchar *)p)) *p = SUBST_CHAR;
+ p++;
+ }
+}
+
+#if 0
+static void conv_unreadable_latin(gchar *str)
+{
+ register guchar *p = str;
+
+ while (*p != '\0') {
+ /* convert CR+LF -> LF */
+ if (*p == '\r' && *(p + 1) == '\n')
+ memmove(p, p + 1, strlen(p));
+ else if ((*p & 0xff) >= 0x7f && (*p & 0xff) <= 0x9f)
+ *p = SUBST_CHAR;
+ p++;
+ }
+}
+#endif
+
+#define NCV '\0'
+
+void conv_mb_alnum(gchar *str)
+{
+ static guchar char_tbl[] = {
+ /* 0xa0 - 0xaf */
+ NCV, ' ', NCV, NCV, ',', '.', NCV, ':',
+ ';', '?', '!', NCV, NCV, NCV, NCV, NCV,
+ /* 0xb0 - 0xbf */
+ NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
+ NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
+ /* 0xc0 - 0xcf */
+ NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
+ NCV, NCV, '(', ')', NCV, NCV, '[', ']',
+ /* 0xd0 - 0xdf */
+ '{', '}', NCV, NCV, NCV, NCV, NCV, NCV,
+ NCV, NCV, NCV, NCV, '+', '-', NCV, NCV,
+ /* 0xe0 - 0xef */
+ NCV, '=', NCV, '<', '>', NCV, NCV, NCV,
+ NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV
+ };
+
+ register guchar *p = (guchar *)str;
+ register gint len;
+
+ len = strlen(str);
+
+ while (len > 1) {
+ if (*p == 0xa3) {
+ register guchar ch = *(p + 1);
+
+ if (ch >= 0xb0 && ch <= 0xfa) {
+ /* [a-zA-Z] */
+ *p = ch & 0x7f;
+ p++;
+ len--;
+ memmove(p, p + 1, len);
+ len--;
+ } else {
+ p += 2;
+ len -= 2;
+ }
+ } else if (*p == 0xa1) {
+ register guchar ch = *(p + 1);
+
+ if (ch >= 0xa0 && ch <= 0xef &&
+ NCV != char_tbl[ch - 0xa0]) {
+ *p = char_tbl[ch - 0xa0];
+ p++;
+ len--;
+ memmove(p, p + 1, len);
+ len--;
+ } else {
+ p += 2;
+ len -= 2;
+ }
+ } else if (iseuckanji(*p)) {
+ p += 2;
+ len -= 2;
+ } else {
+ p++;
+ len--;
+ }
+ }
+}
+
+CharSet conv_guess_ja_encoding(const gchar *str)
+{
+ const guchar *p = (const guchar *)str;
+ CharSet guessed = C_US_ASCII;
+
+ while (*p != '\0') {
+ if (*p == ESC && (*(p + 1) == '$' || *(p + 1) == '(')) {
+ if (guessed == C_US_ASCII)
+ return C_ISO_2022_JP;
+ p += 2;
+ } else if (isascii(*p)) {
+ p++;
+ } else if (iseuckanji(*p) && iseuckanji(*(p + 1))) {
+ if (*p >= 0xfd && *p <= 0xfe)
+ return C_EUC_JP;
+ else if (guessed == C_SHIFT_JIS) {
+ if ((issjiskanji1(*p) &&
+ issjiskanji2(*(p + 1))) ||
+ issjishwkana(*p))
+ guessed = C_SHIFT_JIS;
+ else
+ guessed = C_EUC_JP;
+ } else
+ guessed = C_EUC_JP;
+ p += 2;
+ } else if (issjiskanji1(*p) && issjiskanji2(*(p + 1))) {
+ if (iseuchwkana1(*p) && iseuchwkana2(*(p + 1)))
+ guessed = C_SHIFT_JIS;
+ else
+ return C_SHIFT_JIS;
+ p += 2;
+ } else if (issjishwkana(*p)) {
+ guessed = C_SHIFT_JIS;
+ p++;
+ } else {
+ p++;
+ }
+ }
+
+ return guessed;
+}
+
+static gchar *conv_jistodisp(const gchar *inbuf, gint *error)
+{
+ return conv_jistoutf8(inbuf, error);
+}
+
+static gchar *conv_sjistodisp(const gchar *inbuf, gint *error)
+{
+ return conv_sjistoutf8(inbuf, error);
+}
+
+static gchar *conv_euctodisp(const gchar *inbuf, gint *error)
+{
+ return conv_euctoutf8(inbuf, error);
+}
+
+gchar *conv_utf8todisp(const gchar *inbuf, gint *error)
+{
+ if (g_utf8_validate(inbuf, -1, NULL) == TRUE) {
+ if (error)
+ *error = 0;
+ return g_strdup(inbuf);
+ } else
+ return conv_ustodisp(inbuf, error);
+}
+
+static gchar *conv_anytodisp(const gchar *inbuf, gint *error)
+{
+ gchar *outbuf;
+
+ outbuf = conv_anytoutf8(inbuf, error);
+ if (g_utf8_validate(outbuf, -1, NULL) != TRUE) {
+ if (error)
+ *error = -1;
+ conv_unreadable_8bit(outbuf);
+ }
+
+ return outbuf;
+}
+
+static gchar *conv_ustodisp(const gchar *inbuf, gint *error)
+{
+ gchar *outbuf;
+
+ outbuf = g_strdup(inbuf);
+ conv_unreadable_8bit(outbuf);
+ if (error)
+ *error = 0;
+
+ return outbuf;
+}
+
+gchar *conv_localetodisp(const gchar *inbuf, gint *error)
+{
+ gchar *str;
+
+ str = conv_iconv_strdup(inbuf, conv_get_locale_charset_str(),
+ CS_INTERNAL, error);
+ if (!str)
+ str = conv_utf8todisp(inbuf, NULL);
+
+ return str;
+}
+
+static gchar *conv_noconv(const gchar *inbuf, gint *error)
+{
+ if (error)
+ *error = 0;
+ return g_strdup(inbuf);
+}
+
+static const gchar *
+conv_get_fallback_for_private_encoding(const gchar *encoding)
+{
+ if (encoding && (encoding[0] == 'X' || encoding[0] == 'x') &&
+ encoding[1] == '-') {
+ if (!g_ascii_strcasecmp(encoding, CS_X_GBK))
+ return CS_GBK;
+ }
+
+ return encoding;
+}
+
+CodeConverter *conv_code_converter_new(const gchar *src_encoding,
+ const gchar *dest_encoding)
+{
+ CodeConverter *conv;
+
+ src_encoding = conv_get_fallback_for_private_encoding(src_encoding);
+
+ conv = g_new0(CodeConverter, 1);
+ conv->code_conv_func =
+ conv_get_code_conv_func(src_encoding, dest_encoding);
+ conv->src_encoding = g_strdup(src_encoding);
+ conv->dest_encoding = g_strdup(dest_encoding);
+
+ return conv;
+}
+
+void conv_code_converter_destroy(CodeConverter *conv)
+{
+ g_free(conv->src_encoding);
+ g_free(conv->dest_encoding);
+ g_free(conv);
+}
+
+gchar *conv_convert(CodeConverter *conv, const gchar *inbuf)
+{
+ if (conv->code_conv_func != conv_noconv)
+ return conv->code_conv_func(inbuf, NULL);
+ else
+ return conv_iconv_strdup
+ (inbuf, conv->src_encoding, conv->dest_encoding, NULL);
+}
+
+gchar *conv_codeset_strdup_full(const gchar *inbuf,
+ const gchar *src_encoding,
+ const gchar *dest_encoding,
+ gint *error)
+{
+ CodeConvFunc conv_func;
+
+ src_encoding = conv_get_fallback_for_private_encoding(src_encoding);
+
+ conv_func = conv_get_code_conv_func(src_encoding, dest_encoding);
+ if (conv_func != conv_noconv)
+ return conv_func(inbuf, error);
+
+ return conv_iconv_strdup(inbuf, src_encoding, dest_encoding, error);
+}
+
+CodeConvFunc conv_get_code_conv_func(const gchar *src_encoding,
+ const gchar *dest_encoding)
+{
+ CodeConvFunc code_conv = conv_noconv;
+ CharSet src_charset;
+ CharSet dest_charset;
+
+ if (!src_encoding)
+ src_charset = conv_get_locale_charset();
+ else
+ src_charset = conv_get_charset_from_str(src_encoding);
+
+ /* auto detection mode */
+ if (!src_encoding && !dest_encoding) {
+ if (conv_is_ja_locale())
+ return conv_anytodisp;
+ else
+ return conv_noconv;
+ }
+
+ dest_charset = conv_get_charset_from_str(dest_encoding);
+
+ if (dest_charset == C_US_ASCII)
+ return conv_ustodisp;
+
+ switch (src_charset) {
+ case C_US_ASCII:
+ case C_ISO_8859_1:
+ case C_ISO_8859_2:
+ case C_ISO_8859_3:
+ case C_ISO_8859_4:
+ case C_ISO_8859_5:
+ case C_ISO_8859_6:
+ case C_ISO_8859_7:
+ case C_ISO_8859_8:
+ case C_ISO_8859_9:
+ case C_ISO_8859_10:
+ case C_ISO_8859_11:
+ case C_ISO_8859_13:
+ case C_ISO_8859_14:
+ case C_ISO_8859_15:
+ break;
+ case C_ISO_2022_JP:
+ case C_ISO_2022_JP_2:
+ case C_ISO_2022_JP_3:
+ if (dest_charset == C_AUTO)
+ code_conv = conv_jistodisp;
+ else if (dest_charset == C_EUC_JP)
+ code_conv = conv_jistoeuc;
+ else if (dest_charset == C_UTF_8)
+ code_conv = conv_jistoutf8;
+ break;
+ case C_SHIFT_JIS:
+ if (dest_charset == C_AUTO)
+ code_conv = conv_sjistodisp;
+ else if (dest_charset == C_EUC_JP)
+ code_conv = conv_sjistoeuc;
+ else if (dest_charset == C_UTF_8)
+ code_conv = conv_sjistoutf8;
+ break;
+ case C_EUC_JP:
+ if (dest_charset == C_AUTO)
+ code_conv = conv_euctodisp;
+ else if (dest_charset == C_ISO_2022_JP ||
+ dest_charset == C_ISO_2022_JP_2 ||
+ dest_charset == C_ISO_2022_JP_3)
+ code_conv = conv_euctojis;
+ else if (dest_charset == C_UTF_8)
+ code_conv = conv_euctoutf8;
+ break;
+ case C_UTF_8:
+ if (dest_charset == C_EUC_JP)
+ code_conv = conv_utf8toeuc;
+ else if (dest_charset == C_ISO_2022_JP ||
+ dest_charset == C_ISO_2022_JP_2 ||
+ dest_charset == C_ISO_2022_JP_3)
+ code_conv = conv_utf8tojis;
+ break;
+ default:
+ break;
+ }
+
+ return code_conv;
+}
+
+gchar *conv_iconv_strdup(const gchar *inbuf,
+ const gchar *src_code, const gchar *dest_code,
+ gint *error)
+{
+ iconv_t cd;
+ gchar *outbuf;
+
+ if (!src_code)
+ src_code = conv_get_locale_charset_str();
+ if (!dest_code)
+ dest_code = CS_INTERNAL;
+
+ cd = iconv_open(dest_code, src_code);
+ if (cd == (iconv_t)-1) {
+ if (error)
+ *error = -1;
+ return NULL;
+ }
+
+ outbuf = conv_iconv_strdup_with_cd(inbuf, cd, error);
+
+ iconv_close(cd);
+
+ return outbuf;
+}
+
+gchar *conv_iconv_strdup_with_cd(const gchar *inbuf, iconv_t cd, gint *error)
+{
+ const gchar *inbuf_p;
+ gchar *outbuf;
+ gchar *outbuf_p;
+ size_t in_size;
+ size_t in_left;
+ size_t out_size;
+ size_t out_left;
+ size_t n_conv;
+ size_t len;
+ gint error_ = 0;
+
+ inbuf_p = inbuf;
+ in_size = strlen(inbuf);
+ in_left = in_size;
+ out_size = (in_size + 1) * 2;
+ outbuf = g_malloc(out_size);
+ outbuf_p = outbuf;
+ out_left = out_size;
+
+#define EXPAND_BUF() \
+{ \
+ len = outbuf_p - outbuf; \
+ out_size *= 2; \
+ outbuf = g_realloc(outbuf, out_size); \
+ outbuf_p = outbuf + len; \
+ out_left = out_size - len; \
+}
+
+ while ((n_conv = iconv(cd, (ICONV_CONST gchar **)&inbuf_p, &in_left,
+ &outbuf_p, &out_left)) == (size_t)-1) {
+ if (EILSEQ == errno) {
+ /* g_print("iconv(): at %d: %s\n", in_size - in_left, g_strerror(errno)); */
+ error_ = -1;
+ inbuf_p++;
+ in_left--;
+ if (out_left == 0) {
+ EXPAND_BUF();
+ }
+ *outbuf_p++ = SUBST_CHAR;
+ out_left--;
+ } else if (EINVAL == errno) {
+ error_ = -1;
+ break;
+ } else if (E2BIG == errno) {
+ EXPAND_BUF();
+ } else {
+ g_warning("conv_iconv_strdup(): %s\n",
+ g_strerror(errno));
+ error_ = -1;
+ break;
+ }
+ }
+
+ while ((n_conv = iconv(cd, NULL, NULL, &outbuf_p, &out_left)) ==
+ (size_t)-1) {
+ if (E2BIG == errno) {
+ EXPAND_BUF();
+ } else {
+ g_warning("conv_iconv_strdup(): %s\n",
+ g_strerror(errno));
+ error_ = -1;
+ break;
+ }
+ }
+
+#undef EXPAND_BUF
+
+ len = outbuf_p - outbuf;
+ outbuf = g_realloc(outbuf, len + 1);
+ outbuf[len] = '\0';
+
+ if (error)
+ *error = error_;
+
+ return outbuf;
+}
+
+static const struct {
+ CharSet charset;
+ gchar *const name;
+} charsets[] = {
+ {C_US_ASCII, CS_US_ASCII},
+ {C_US_ASCII, CS_ANSI_X3_4_1968},
+ {C_UTF_8, CS_UTF_8},
+ {C_UTF_7, CS_UTF_7},
+ {C_ISO_8859_1, CS_ISO_8859_1},
+ {C_ISO_8859_2, CS_ISO_8859_2},
+ {C_ISO_8859_3, CS_ISO_8859_3},
+ {C_ISO_8859_4, CS_ISO_8859_4},
+ {C_ISO_8859_5, CS_ISO_8859_5},
+ {C_ISO_8859_6, CS_ISO_8859_6},
+ {C_ISO_8859_7, CS_ISO_8859_7},
+ {C_ISO_8859_8, CS_ISO_8859_8},
+ {C_ISO_8859_9, CS_ISO_8859_9},
+ {C_ISO_8859_10, CS_ISO_8859_10},
+ {C_ISO_8859_11, CS_ISO_8859_11},
+ {C_ISO_8859_13, CS_ISO_8859_13},
+ {C_ISO_8859_14, CS_ISO_8859_14},
+ {C_ISO_8859_15, CS_ISO_8859_15},
+ {C_BALTIC, CS_BALTIC},
+ {C_CP1250, CS_CP1250},
+ {C_CP1251, CS_CP1251},
+ {C_CP1252, CS_CP1252},
+ {C_CP1253, CS_CP1253},
+ {C_CP1254, CS_CP1254},
+ {C_CP1255, CS_CP1255},
+ {C_CP1256, CS_CP1256},
+ {C_CP1257, CS_CP1257},
+ {C_CP1258, CS_CP1258},
+ {C_WINDOWS_1250, CS_WINDOWS_1250},
+ {C_WINDOWS_1251, CS_WINDOWS_1251},
+ {C_WINDOWS_1252, CS_WINDOWS_1252},
+ {C_WINDOWS_1253, CS_WINDOWS_1253},
+ {C_WINDOWS_1254, CS_WINDOWS_1254},
+ {C_WINDOWS_1255, CS_WINDOWS_1255},
+ {C_WINDOWS_1256, CS_WINDOWS_1256},
+ {C_WINDOWS_1257, CS_WINDOWS_1257},
+ {C_WINDOWS_1258, CS_WINDOWS_1258},
+ {C_KOI8_R, CS_KOI8_R},
+ {C_KOI8_T, CS_KOI8_T},
+ {C_KOI8_U, CS_KOI8_U},
+ {C_ISO_2022_JP, CS_ISO_2022_JP},
+ {C_ISO_2022_JP_2, CS_ISO_2022_JP_2},
+ {C_ISO_2022_JP_3, CS_ISO_2022_JP_3},
+ {C_EUC_JP, CS_EUC_JP},
+ {C_EUC_JP, CS_EUCJP},
+ {C_EUC_JP_MS, CS_EUC_JP_MS},
+ {C_SHIFT_JIS, CS_SHIFT_JIS},
+ {C_SHIFT_JIS, CS_SHIFT__JIS},
+ {C_SHIFT_JIS, CS_SJIS},
+ {C_ISO_2022_KR, CS_ISO_2022_KR},
+ {C_EUC_KR, CS_EUC_KR},
+ {C_ISO_2022_CN, CS_ISO_2022_CN},
+ {C_EUC_CN, CS_EUC_CN},
+ {C_GB2312, CS_GB2312},
+ {C_GBK, CS_GBK},
+ {C_EUC_TW, CS_EUC_TW},
+ {C_BIG5, CS_BIG5},
+ {C_BIG5_HKSCS, CS_BIG5_HKSCS},
+ {C_TIS_620, CS_TIS_620},
+ {C_WINDOWS_874, CS_WINDOWS_874},
+ {C_GEORGIAN_PS, CS_GEORGIAN_PS},
+ {C_TCVN5712_1, CS_TCVN5712_1},
+};
+
+static const struct {
+ gchar *const locale;
+ CharSet charset;
+ CharSet out_charset;
+} locale_table[] = {
+ {"ja_JP.eucJP" , C_EUC_JP , C_ISO_2022_JP},
+ {"ja_JP.EUC-JP" , C_EUC_JP , C_ISO_2022_JP},
+ {"ja_JP.EUC" , C_EUC_JP , C_ISO_2022_JP},
+ {"ja_JP.ujis" , C_EUC_JP , C_ISO_2022_JP},
+ {"ja_JP.SJIS" , C_SHIFT_JIS , C_ISO_2022_JP},
+ {"ja_JP.JIS" , C_ISO_2022_JP , C_ISO_2022_JP},
+#ifdef G_OS_WIN32
+ {"ja_JP" , C_SHIFT_JIS , C_ISO_2022_JP},
+#else
+ {"ja_JP" , C_EUC_JP , C_ISO_2022_JP},
+#endif
+ {"ko_KR.EUC-KR" , C_EUC_KR , C_EUC_KR},
+ {"ko_KR" , C_EUC_KR , C_EUC_KR},
+ {"zh_CN.GB2312" , C_GB2312 , C_GB2312},
+ {"zh_CN.GBK" , C_GBK , C_GBK},
+ {"zh_CN" , C_GB2312 , C_GB2312},
+ {"zh_HK" , C_BIG5_HKSCS , C_BIG5_HKSCS},
+ {"zh_TW.eucTW" , C_EUC_TW , C_BIG5},
+ {"zh_TW.EUC-TW" , C_EUC_TW , C_BIG5},
+ {"zh_TW.Big5" , C_BIG5 , C_BIG5},
+ {"zh_TW" , C_BIG5 , C_BIG5},
+
+ {"ru_RU.KOI8-R" , C_KOI8_R , C_KOI8_R},
+ {"ru_RU.KOI8R" , C_KOI8_R , C_KOI8_R},
+ {"ru_RU.CP1251" , C_WINDOWS_1251, C_KOI8_R},
+ {"ru_RU" , C_ISO_8859_5 , C_KOI8_R},
+ {"tg_TJ" , C_KOI8_T , C_KOI8_T},
+ {"ru_UA" , C_KOI8_U , C_KOI8_U},
+ {"uk_UA.CP1251" , C_WINDOWS_1251, C_KOI8_U},
+ {"uk_UA" , C_KOI8_U , C_KOI8_U},
+
+ {"be_BY" , C_WINDOWS_1251, C_WINDOWS_1251},
+ {"bg_BG" , C_WINDOWS_1251, C_WINDOWS_1251},
+
+ {"yi_US" , C_WINDOWS_1255, C_WINDOWS_1255},
+
+ {"af_ZA" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"br_FR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"ca_ES" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"da_DK" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"de_AT" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"de_BE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"de_CH" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"de_DE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"de_LU" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_AU" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_BW" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_CA" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_DK" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_GB" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_HK" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_IE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_NZ" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_PH" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_SG" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_US" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_ZA" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"en_ZW" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_AR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_BO" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_CL" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_CO" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_CR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_DO" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_EC" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_ES" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_GT" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_HN" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_MX" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_NI" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_PA" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_PE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_PR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_PY" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_SV" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_US" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_UY" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"es_VE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"et_EE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"eu_ES" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fi_FI" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fo_FO" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fr_BE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fr_CA" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fr_CH" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fr_FR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"fr_LU" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"ga_IE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"gl_ES" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"gv_GB" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"id_ID" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"is_IS" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"it_CH" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"it_IT" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"kl_GL" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"kw_GB" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"ms_MY" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"nl_BE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"nl_NL" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"nn_NO" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"no_NO" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"oc_FR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"pt_BR" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"pt_PT" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"sq_AL" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"sv_FI" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"sv_SE" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"tl_PH" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"uz_UZ" , C_ISO_8859_1 , C_ISO_8859_1},
+ {"wa_BE" , C_ISO_8859_1 , C_ISO_8859_1},
+
+ {"bs_BA" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"cs_CZ" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"hr_HR" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"hu_HU" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"pl_PL" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"ro_RO" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"sk_SK" , C_ISO_8859_2 , C_ISO_8859_2},
+ {"sl_SI" , C_ISO_8859_2 , C_ISO_8859_2},
+
+ {"sr_YU@cyrillic" , C_ISO_8859_5 , C_ISO_8859_5},
+ {"sr_YU" , C_ISO_8859_2 , C_ISO_8859_2},
+
+ {"mt_MT" , C_ISO_8859_3 , C_ISO_8859_3},
+
+ {"lt_LT.iso88594" , C_ISO_8859_4 , C_ISO_8859_4},
+ {"lt_LT.ISO8859-4" , C_ISO_8859_4 , C_ISO_8859_4},
+ {"lt_LT.ISO_8859-4" , C_ISO_8859_4 , C_ISO_8859_4},
+ {"lt_LT" , C_ISO_8859_13 , C_ISO_8859_13},
+
+ {"mk_MK" , C_ISO_8859_5 , C_ISO_8859_5},
+
+ {"ar_AE" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_BH" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_DZ" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_EG" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_IQ" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_JO" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_KW" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_LB" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_LY" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_MA" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_OM" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_QA" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_SA" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_SD" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_SY" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_TN" , C_ISO_8859_6 , C_ISO_8859_6},
+ {"ar_YE" , C_ISO_8859_6 , C_ISO_8859_6},
+
+ {"el_GR" , C_ISO_8859_7 , C_ISO_8859_7},
+ {"he_IL" , C_ISO_8859_8 , C_ISO_8859_8},
+ {"iw_IL" , C_ISO_8859_8 , C_ISO_8859_8},
+ {"tr_TR" , C_ISO_8859_9 , C_ISO_8859_9},
+
+ {"lv_LV" , C_ISO_8859_13 , C_ISO_8859_13},
+ {"mi_NZ" , C_ISO_8859_13 , C_ISO_8859_13},
+
+ {"cy_GB" , C_ISO_8859_14 , C_ISO_8859_14},
+
+ {"ar_IN" , C_UTF_8 , C_UTF_8},
+ {"en_IN" , C_UTF_8 , C_UTF_8},
+ {"se_NO" , C_UTF_8 , C_UTF_8},
+ {"ta_IN" , C_UTF_8 , C_UTF_8},
+ {"te_IN" , C_UTF_8 , C_UTF_8},
+ {"ur_PK" , C_UTF_8 , C_UTF_8},
+
+ {"th_TH" , C_TIS_620 , C_TIS_620},
+ /* {"th_TH" , C_WINDOWS_874}, */
+ /* {"th_TH" , C_ISO_8859_11}, */
+
+ {"ka_GE" , C_GEORGIAN_PS , C_GEORGIAN_PS},
+ {"vi_VN.TCVN" , C_TCVN5712_1 , C_TCVN5712_1},
+
+ {"C" , C_US_ASCII , C_US_ASCII},
+ {"POSIX" , C_US_ASCII , C_US_ASCII},
+ {"ANSI_X3.4-1968" , C_US_ASCII , C_US_ASCII},
+};
+
+static GHashTable *conv_get_charset_to_str_table(void)
+{
+ static GHashTable *table;
+ gint i;
+
+ if (table)
+ return table;
+
+ table = g_hash_table_new(NULL, g_direct_equal);
+
+ for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
+ if (g_hash_table_lookup(table, GUINT_TO_POINTER(charsets[i].charset))
+ == NULL) {
+ g_hash_table_insert
+ (table, GUINT_TO_POINTER(charsets[i].charset),
+ charsets[i].name);
+ }
+ }
+
+ return table;
+}
+
+static GHashTable *conv_get_charset_from_str_table(void)
+{
+ static GHashTable *table;
+ gint i;
+
+ if (table)
+ return table;
+
+ table = g_hash_table_new(str_case_hash, str_case_equal);
+
+ for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
+ g_hash_table_insert(table, charsets[i].name,
+ GUINT_TO_POINTER(charsets[i].charset));
+ }
+
+ return table;
+}
+
+const gchar *conv_get_charset_str(CharSet charset)
+{
+ GHashTable *table;
+
+ table = conv_get_charset_to_str_table();
+ return g_hash_table_lookup(table, GUINT_TO_POINTER(charset));
+}
+
+CharSet conv_get_charset_from_str(const gchar *charset)
+{
+ GHashTable *table;
+
+ if (!charset) return C_AUTO;
+
+ table = conv_get_charset_from_str_table();
+ return GPOINTER_TO_UINT(g_hash_table_lookup(table, charset));
+}
+
+CharSet conv_get_locale_charset(void)
+{
+ static CharSet cur_charset = -1;
+ const gchar *cur_locale;
+ const gchar *p;
+ gint i;
+
+ if (cur_charset != -1)
+ return cur_charset;
+
+ cur_locale = conv_get_current_locale();
+ if (!cur_locale) {
+ cur_charset = C_US_ASCII;
+ return cur_charset;
+ }
+
+ if (strcasestr(cur_locale, "UTF-8")) {
+ cur_charset = C_UTF_8;
+ return cur_charset;
+ }
+
+ if ((p = strcasestr(cur_locale, "@euro")) && p[5] == '\0') {
+ cur_charset = C_ISO_8859_15;
+ return cur_charset;
+ }
+
+ for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
+ const gchar *p;
+
+ /* "ja_JP.EUC" matches with "ja_JP.eucJP", "ja_JP.EUC" and
+ "ja_JP". "ja_JP" matches with "ja_JP.xxxx" and "ja" */
+ if (!g_ascii_strncasecmp(cur_locale, locale_table[i].locale,
+ strlen(locale_table[i].locale))) {
+ cur_charset = locale_table[i].charset;
+ return cur_charset;
+ } else if ((p = strchr(locale_table[i].locale, '_')) &&
+ !strchr(p + 1, '.')) {
+ if (strlen(cur_locale) == 2 &&
+ !g_ascii_strncasecmp(cur_locale,
+ locale_table[i].locale, 2)) {
+ cur_charset = locale_table[i].charset;
+ return cur_charset;
+ }
+ }
+ }
+
+ cur_charset = C_AUTO;
+ return cur_charset;
+}
+
+const gchar *conv_get_locale_charset_str(void)
+{
+ static const gchar *codeset = NULL;
+
+ if (!codeset)
+ codeset = conv_get_charset_str(conv_get_locale_charset());
+
+ return codeset ? codeset : CS_INTERNAL;
+}
+
+CharSet conv_get_internal_charset(void)
+{
+ return C_INTERNAL;
+}
+
+const gchar *conv_get_internal_charset_str(void)
+{
+ return CS_INTERNAL;
+}
+
+CharSet conv_get_outgoing_charset(void)
+{
+ static CharSet out_charset = -1;
+ const gchar *cur_locale;
+ const gchar *p;
+ gint i;
+
+ if (out_charset != -1)
+ return out_charset;
+
+ cur_locale = conv_get_current_locale();
+ if (!cur_locale) {
+ out_charset = C_AUTO;
+ return out_charset;
+ }
+
+ if ((p = strcasestr(cur_locale, "@euro")) && p[5] == '\0') {
+ out_charset = C_ISO_8859_15;
+ return out_charset;
+ }
+
+ for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
+ const gchar *p;
+
+ if (!g_ascii_strncasecmp(cur_locale, locale_table[i].locale,
+ strlen(locale_table[i].locale))) {
+ out_charset = locale_table[i].out_charset;
+ break;
+ } else if ((p = strchr(locale_table[i].locale, '_')) &&
+ !strchr(p + 1, '.')) {
+ if (strlen(cur_locale) == 2 &&
+ !g_ascii_strncasecmp(cur_locale,
+ locale_table[i].locale, 2)) {
+ out_charset = locale_table[i].out_charset;
+ break;
+ }
+ }
+ }
+
+ return out_charset;
+}
+
+const gchar *conv_get_outgoing_charset_str(void)
+{
+ CharSet out_charset;
+ const gchar *str;
+
+ out_charset = conv_get_outgoing_charset();
+ str = conv_get_charset_str(out_charset);
+
+ return str ? str : CS_UTF_8;
+}
+
+gboolean conv_is_multibyte_encoding(CharSet encoding)
+{
+ switch (encoding) {
+ case C_EUC_JP:
+ case C_EUC_JP_MS:
+ case C_EUC_KR:
+ case C_EUC_TW:
+ case C_EUC_CN:
+ case C_ISO_2022_JP:
+ case C_ISO_2022_JP_2:
+ case C_ISO_2022_JP_3:
+ case C_ISO_2022_KR:
+ case C_ISO_2022_CN:
+ case C_SHIFT_JIS:
+ case C_GB2312:
+ case C_GBK:
+ case C_BIG5:
+ case C_UTF_8:
+ case C_UTF_7:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
+
+const gchar *conv_get_current_locale(void)
+{
+ static const gchar *cur_locale;
+
+ if (!cur_locale) {
+#ifdef G_OS_WIN32
+ cur_locale = g_win32_getlocale();
+#else
+ cur_locale = g_getenv("LC_ALL");
+ if (!cur_locale) cur_locale = g_getenv("LC_CTYPE");
+ if (!cur_locale) cur_locale = g_getenv("LANG");
+ if (!cur_locale) cur_locale = setlocale(LC_CTYPE, NULL);
+#endif /* G_OS_WIN32 */
+
+ debug_print("current locale: %s\n",
+ cur_locale ? cur_locale : "(none)");
+ }
+
+ return cur_locale;
+}
+
+gboolean conv_is_ja_locale(void)
+{
+ static gint is_ja_locale = -1;
+ const gchar *cur_locale;
+
+ if (is_ja_locale != -1)
+ return is_ja_locale != 0;
+
+ is_ja_locale = 0;
+ cur_locale = conv_get_current_locale();
+ if (cur_locale) {
+ if (g_ascii_strncasecmp(cur_locale, "ja", 2) == 0)
+ is_ja_locale = 1;
+ }
+
+ return is_ja_locale != 0;
+}
+
+gchar *conv_unmime_header(const gchar *str, const gchar *default_encoding)
+{
+ gchar *buf;
+ gchar *decoded_str;
+
+ if (is_ascii_str(str))
+ return unmime_header(str);
+
+ if (default_encoding) {
+ buf = conv_codeset_strdup
+ (str, default_encoding, CS_INTERNAL);
+ if (buf) {
+ decoded_str = unmime_header(buf);
+ g_free(buf);
+ return decoded_str;
+ }
+ }
+
+ if (conv_is_ja_locale())
+ buf = conv_anytodisp(str, NULL);
+ else
+ buf = conv_localetodisp(str, NULL);
+
+ decoded_str = unmime_header(buf);
+ g_free(buf);
+
+ return decoded_str;
+}
+
+#define MAX_LINELEN 76
+#define MAX_HARD_LINELEN 996
+#define MIMESEP_BEGIN "=?"
+#define MIMESEP_END "?="
+
+#define B64LEN(len) ((len) / 3 * 4 + ((len) % 3 ? 4 : 0))
+
+#define LBREAK_IF_REQUIRED(cond, is_plain_text) \
+{ \
+ if (len - (destp - dest) < MAX_LINELEN + 2) { \
+ *destp = '\0'; \
+ return; \
+ } \
+ \
+ if ((cond) && *srcp) { \
+ if (destp > dest && left < MAX_LINELEN - 1) { \
+ if (g_ascii_isspace(*(destp - 1))) \
+ destp--; \
+ else if (is_plain_text && \
+ g_ascii_isspace(*srcp)) \
+ srcp++; \
+ if (*srcp) { \
+ *destp++ = '\n'; \
+ *destp++ = ' '; \
+ left = MAX_LINELEN - 1; \
+ } \
+ } \
+ } \
+}
+
+void conv_encode_header(gchar *dest, gint len, const gchar *src,
+ gint header_len, gboolean addr_field,
+ const gchar *out_encoding)
+{
+ const gchar *cur_encoding;
+ gint mimestr_len;
+ gchar *mimesep_enc;
+ gint left;
+ const gchar *srcp = src;
+ gchar *destp = dest;
+ gboolean use_base64;
+
+ g_return_if_fail(g_utf8_validate(src, -1, NULL) == TRUE);
+
+ if (MB_CUR_MAX > 1) {
+ use_base64 = TRUE;
+ mimesep_enc = "?B?";
+ } else {
+ use_base64 = FALSE;
+ mimesep_enc = "?Q?";
+ }
+
+ cur_encoding = CS_INTERNAL;
+ if (!out_encoding)
+ out_encoding = conv_get_outgoing_charset_str();
+ if (!strcmp(out_encoding, CS_US_ASCII))
+ out_encoding = CS_ISO_8859_1;
+
+ mimestr_len = strlen(MIMESEP_BEGIN) + strlen(out_encoding) +
+ strlen(mimesep_enc) + strlen(MIMESEP_END);
+
+ left = MAX_LINELEN - header_len;
+
+ while (*srcp) {
+ LBREAK_IF_REQUIRED(left <= 0, TRUE);
+
+ while (g_ascii_isspace(*srcp)) {
+ *destp++ = *srcp++;
+ left--;
+ LBREAK_IF_REQUIRED(left <= 0, TRUE);
+ }
+
+ /* output as it is if the next word is ASCII string */
+ if (!is_next_nonascii(srcp)) {
+ gint word_len;
+
+ word_len = get_next_word_len(srcp);
+ LBREAK_IF_REQUIRED(left < word_len, TRUE);
+ while (word_len > 0) {
+ LBREAK_IF_REQUIRED(left + (MAX_HARD_LINELEN - MAX_LINELEN) <= 0, TRUE)
+ *destp++ = *srcp++;
+ left--;
+ word_len--;
+ }
+
+ continue;
+ }
+
+ /* don't include parentheses in encoded strings */
+ if (addr_field && (*srcp == '(' || *srcp == ')')) {
+ LBREAK_IF_REQUIRED(left < 2, FALSE);
+ *destp++ = *srcp++;
+ left--;
+ }
+
+ while (1) {
+ gint mb_len = 0;
+ gint cur_len = 0;
+ gchar *part_str;
+ gchar *out_str;
+ gchar *enc_str;
+ const gchar *p = srcp;
+ gint out_str_len;
+ gint out_enc_str_len;
+ gint mime_block_len;
+ gboolean cont = FALSE;
+
+ while (*p != '\0') {
+ if (g_ascii_isspace(*p) &&
+ !is_next_nonascii(p + 1))
+ break;
+ /* don't include parentheses in encoded
+ strings */
+ if (addr_field && (*p == '(' || *p == ')'))
+ break;
+
+ mb_len = g_utf8_skip[*(guchar *)p];
+
+ Xstrndup_a(part_str, srcp, cur_len + mb_len, );
+ out_str = conv_codeset_strdup
+ (part_str, cur_encoding, out_encoding);
+ if (!out_str) {
+ g_warning("conv_encode_header(): code conversion failed\n");
+ conv_unreadable_8bit(part_str);
+ out_str = g_strdup(part_str);
+ }
+ out_str_len = strlen(out_str);
+
+ if (use_base64)
+ out_enc_str_len = B64LEN(out_str_len);
+ else
+ out_enc_str_len =
+ qp_get_q_encoding_len
+ ((guchar *)out_str);
+
+ g_free(out_str);
+
+ if (mimestr_len + out_enc_str_len <= left) {
+ cur_len += mb_len;
+ p += mb_len;
+ } else if (cur_len == 0) {
+ LBREAK_IF_REQUIRED(1, FALSE);
+ continue;
+ } else {
+ cont = TRUE;
+ break;
+ }
+ }
+
+ if (cur_len > 0) {
+ Xstrndup_a(part_str, srcp, cur_len, );
+ out_str = conv_codeset_strdup
+ (part_str, cur_encoding, out_encoding);
+ if (!out_str) {
+ g_warning("conv_encode_header(): code conversion failed\n");
+ conv_unreadable_8bit(part_str);
+ out_str = g_strdup(part_str);
+ }
+ out_str_len = strlen(out_str);
+
+ if (use_base64)
+ out_enc_str_len = B64LEN(out_str_len);
+ else
+ out_enc_str_len =
+ qp_get_q_encoding_len
+ ((guchar *)out_str);
+
+ Xalloca(enc_str, out_enc_str_len + 1, );
+ if (use_base64)
+ base64_encode(enc_str,
+ (guchar *)out_str,
+ out_str_len);
+ else
+ qp_q_encode(enc_str, (guchar *)out_str);
+
+ g_free(out_str);
+
+ /* output MIME-encoded string block */
+ mime_block_len = mimestr_len + strlen(enc_str);
+ g_snprintf(destp, mime_block_len + 1,
+ MIMESEP_BEGIN "%s%s%s" MIMESEP_END,
+ out_encoding, mimesep_enc, enc_str);
+ destp += mime_block_len;
+ srcp += cur_len;
+
+ left -= mime_block_len;
+ }
+
+ LBREAK_IF_REQUIRED(cont, FALSE);
+
+ if (cur_len == 0)
+ break;
+ }
+ }
+
+ *destp = '\0';
+}
+
+#undef LBREAK_IF_REQUIRED
+
+gint conv_copy_file(const gchar *src, const gchar *dest, const gchar *encoding)
+{
+ FILE *src_fp, *dest_fp;
+ gchar buf[BUFFSIZE];
+ CodeConverter *conv;
+ gboolean err = FALSE;
+
+ if ((src_fp = g_fopen(src, "rb")) == NULL) {
+ FILE_OP_ERROR(src, "fopen");
+ return -1;
+ }
+ if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
+ FILE_OP_ERROR(dest, "fopen");
+ fclose(src_fp);
+ return -1;
+ }
+
+ if (change_file_mode_rw(dest_fp, dest) < 0) {
+ FILE_OP_ERROR(dest, "chmod");
+ g_warning("can't change file mode\n");
+ }
+
+ conv = conv_code_converter_new(encoding, NULL);
+
+ while (fgets(buf, sizeof(buf), src_fp) != NULL) {
+ gchar *outbuf;
+
+ outbuf = conv_convert(conv, buf);
+ if (outbuf) {
+ fputs(outbuf, dest_fp);
+ g_free(outbuf);
+ } else
+ fputs(buf, dest_fp);
+ }
+
+ conv_code_converter_destroy(conv);
+
+ if (ferror(src_fp)) {
+ FILE_OP_ERROR(src, "fgets");
+ err = TRUE;
+ }
+ fclose(src_fp);
+ if (fclose(dest_fp) == EOF) {
+ FILE_OP_ERROR(dest, "fclose");
+ err = TRUE;
+ }
+ if (err) {
+ g_unlink(dest);
+ return -1;
+ }
+
+ return 0;
+}
+
+gint conv_copy_dir(const gchar *src, const gchar *dest, const gchar *encoding)
+{
+ GDir *dir;
+ const gchar *dir_name;
+ gchar *src_file;
+ gchar *dest_file;
+
+ if ((dir = g_dir_open(src, 0, NULL)) == NULL) {
+ g_warning("failed to open directory: %s\n", src);
+ return -1;
+ }
+
+ if (make_dir_hier(dest) < 0) {
+ g_dir_close(dir);
+ return -1;
+ }
+
+ while ((dir_name = g_dir_read_name(dir)) != NULL) {
+ src_file = g_strconcat(src, G_DIR_SEPARATOR_S, dir_name, NULL);
+ dest_file = g_strconcat(dest, G_DIR_SEPARATOR_S, dir_name,
+ NULL);
+ if (is_file_exist(src_file))
+ conv_copy_file(src_file, dest_file, encoding);
+ g_free(dest_file);
+ g_free(src_file);
+ }
+
+ g_dir_close(dir);
+
+ return 0;
+}
+
+gchar *conv_filename_from_utf8(const gchar *utf8_file)
+{
+ gchar *fs_file;
+ GError *error = NULL;
+
+ fs_file = g_filename_from_utf8(utf8_file, -1, NULL, NULL, &error);
+ if (error) {
+ g_warning("failed to convert encoding of file name: %s\n",
+ error->message);
+ g_error_free(error);
+ }
+ if (!fs_file)
+ fs_file = g_strdup(utf8_file);
+
+ return fs_file;
+}
+
+gchar *conv_filename_to_utf8(const gchar *fs_file)
+{
+ gchar *utf8_file;
+ GError *error = NULL;
+
+ utf8_file = g_filename_to_utf8(fs_file, -1, NULL, NULL, &error);
+ if (error) {
+ g_warning("failed to convert encoding of file name: %s\n",
+ error->message);
+ g_error_free(error);
+ }
+ if (!utf8_file)
+ utf8_file = g_strdup(fs_file);
+
+ return utf8_file;
+}
diff --git a/libsylph/codeconv.h b/libsylph/codeconv.h
new file mode 100644
index 00000000..833b1402
--- /dev/null
+++ b/libsylph/codeconv.h
@@ -0,0 +1,239 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __CODECONV_H__
+#define __CODECONV_H__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+#include <iconv.h>
+
+typedef struct _CodeConverter CodeConverter;
+
+typedef enum
+{
+ C_AUTO,
+ C_US_ASCII,
+ C_UTF_8,
+ C_UTF_7,
+ C_ISO_8859_1,
+ C_ISO_8859_2,
+ C_ISO_8859_3,
+ C_ISO_8859_4,
+ C_ISO_8859_5,
+ C_ISO_8859_6,
+ C_ISO_8859_7,
+ C_ISO_8859_8,
+ C_ISO_8859_9,
+ C_ISO_8859_10,
+ C_ISO_8859_11,
+ C_ISO_8859_13,
+ C_ISO_8859_14,
+ C_ISO_8859_15,
+ C_BALTIC,
+ C_CP1250,
+ C_CP1251,
+ C_CP1252,
+ C_CP1253,
+ C_CP1254,
+ C_CP1255,
+ C_CP1256,
+ C_CP1257,
+ C_CP1258,
+ C_WINDOWS_1250,
+ C_WINDOWS_1251,
+ C_WINDOWS_1252,
+ C_WINDOWS_1253,
+ C_WINDOWS_1254,
+ C_WINDOWS_1255,
+ C_WINDOWS_1256,
+ C_WINDOWS_1257,
+ C_WINDOWS_1258,
+ C_KOI8_R,
+ C_KOI8_T,
+ C_KOI8_U,
+ C_ISO_2022_JP,
+ C_ISO_2022_JP_2,
+ C_ISO_2022_JP_3,
+ C_EUC_JP,
+ C_EUC_JP_MS,
+ C_SHIFT_JIS,
+ C_ISO_2022_KR,
+ C_EUC_KR,
+ C_ISO_2022_CN,
+ C_EUC_CN,
+ C_GB2312,
+ C_GBK,
+ C_EUC_TW,
+ C_BIG5,
+ C_BIG5_HKSCS,
+ C_TIS_620,
+ C_WINDOWS_874,
+ C_GEORGIAN_PS,
+ C_TCVN5712_1
+} CharSet;
+
+typedef gchar *(*CodeConvFunc) (const gchar *inbuf, gint *error);
+
+struct _CodeConverter
+{
+ CodeConvFunc code_conv_func;
+ gchar *src_encoding;
+ gchar *dest_encoding;
+};
+
+#define CS_AUTO "AUTO"
+#define CS_US_ASCII "US-ASCII"
+#define CS_ANSI_X3_4_1968 "ANSI_X3.4-1968"
+#define CS_UTF_8 "UTF-8"
+#define CS_UTF_7 "UTF-7"
+#define CS_ISO_8859_1 "ISO-8859-1"
+#define CS_ISO_8859_2 "ISO-8859-2"
+#define CS_ISO_8859_3 "ISO-8859-3"
+#define CS_ISO_8859_4 "ISO-8859-4"
+#define CS_ISO_8859_5 "ISO-8859-5"
+#define CS_ISO_8859_6 "ISO-8859-6"
+#define CS_ISO_8859_7 "ISO-8859-7"
+#define CS_ISO_8859_8 "ISO-8859-8"
+#define CS_ISO_8859_9 "ISO-8859-9"
+#define CS_ISO_8859_10 "ISO-8859-10"
+#define CS_ISO_8859_11 "ISO-8859-11"
+#define CS_ISO_8859_13 "ISO-8859-13"
+#define CS_ISO_8859_14 "ISO-8859-14"
+#define CS_ISO_8859_15 "ISO-8859-15"
+#define CS_BALTIC "BALTIC"
+#define CS_CP1250 "CP1250"
+#define CS_CP1251 "CP1251"
+#define CS_CP1252 "CP1252"
+#define CS_CP1253 "CP1253"
+#define CS_CP1254 "CP1254"
+#define CS_CP1255 "CP1255"
+#define CS_CP1256 "CP1256"
+#define CS_CP1257 "CP1257"
+#define CS_CP1258 "CP1258"
+#define CS_WINDOWS_1250 "Windows-1250"
+#define CS_WINDOWS_1251 "Windows-1251"
+#define CS_WINDOWS_1252 "Windows-1252"
+#define CS_WINDOWS_1253 "Windows-1253"
+#define CS_WINDOWS_1254 "Windows-1254"
+#define CS_WINDOWS_1255 "Windows-1255"
+#define CS_WINDOWS_1256 "Windows-1256"
+#define CS_WINDOWS_1257 "Windows-1257"
+#define CS_WINDOWS_1258 "Windows-1258"
+#define CS_KOI8_R "KOI8-R"
+#define CS_KOI8_T "KOI8-T"
+#define CS_KOI8_U "KOI8-U"
+#define CS_ISO_2022_JP "ISO-2022-JP"
+#define CS_ISO_2022_JP_2 "ISO-2022-JP-2"
+#define CS_ISO_2022_JP_3 "ISO-2022-JP-3"
+#define CS_EUC_JP "EUC-JP"
+#define CS_EUCJP "EUCJP"
+#define CS_EUC_JP_MS "EUC-JP-MS"
+#define CS_SHIFT_JIS "Shift_JIS"
+#define CS_SHIFT__JIS "SHIFT-JIS"
+#define CS_SJIS "SJIS"
+#define CS_X_SJIS "X-SJIS"
+#define CS_ISO_2022_KR "ISO-2022-KR"
+#define CS_EUC_KR "EUC-KR"
+#define CS_ISO_2022_CN "ISO-2022-CN"
+#define CS_EUC_CN "EUC-CN"
+#define CS_GB2312 "GB2312"
+#define CS_GBK "GBK"
+#define CS_X_GBK "X-GBK"
+#define CS_EUC_TW "EUC-TW"
+#define CS_BIG5 "Big5"
+#define CS_BIG5_HKSCS "BIG5-HKSCS"
+#define CS_TIS_620 "TIS-620"
+#define CS_WINDOWS_874 "Windows-874"
+#define CS_GEORGIAN_PS "GEORGIAN-PS"
+#define CS_TCVN5712_1 "TCVN5712-1"
+
+#define C_INTERNAL C_UTF_8
+#define CS_INTERNAL CS_UTF_8
+
+//void conv_mb_alnum(gchar *str);
+
+CharSet conv_guess_ja_encoding (const gchar *str);
+
+gchar *conv_utf8todisp (const gchar *inbuf,
+ gint *error);
+gchar *conv_localetodisp (const gchar *inbuf,
+ gint *error);
+
+CodeConverter *conv_code_converter_new (const gchar *src_encoding,
+ const gchar *dest_encoding);
+void conv_code_converter_destroy (CodeConverter *conv);
+gchar *conv_convert (CodeConverter *conv,
+ const gchar *inbuf);
+
+#define conv_codeset_strdup(inbuf, src_code, dest_code) \
+ (conv_codeset_strdup_full(inbuf, src_code, dest_code, NULL))
+
+gchar *conv_codeset_strdup_full (const gchar *inbuf,
+ const gchar *src_encoding,
+ const gchar *dest_encoding,
+ gint *error);
+
+CodeConvFunc conv_get_code_conv_func (const gchar *src_encoding,
+ const gchar *dest_encoding);
+
+gchar *conv_iconv_strdup (const gchar *inbuf,
+ const gchar *src_encoding,
+ const gchar *dest_encoding,
+ gint *error);
+gchar *conv_iconv_strdup_with_cd (const gchar *inbuf,
+ iconv_t cd,
+ gint *error);
+
+const gchar *conv_get_charset_str (CharSet charset);
+CharSet conv_get_charset_from_str (const gchar *charset);
+CharSet conv_get_locale_charset (void);
+const gchar *conv_get_locale_charset_str (void);
+CharSet conv_get_internal_charset (void);
+const gchar *conv_get_internal_charset_str (void);
+CharSet conv_get_outgoing_charset (void);
+const gchar *conv_get_outgoing_charset_str (void);
+gboolean conv_is_multibyte_encoding (CharSet encoding);
+
+const gchar *conv_get_current_locale (void);
+gboolean conv_is_ja_locale (void);
+
+gchar *conv_unmime_header (const gchar *str,
+ const gchar *default_encoding);
+void conv_encode_header (gchar *dest,
+ gint len,
+ const gchar *src,
+ gint header_len,
+ gboolean addr_field,
+ const gchar *out_encoding);
+
+gint conv_copy_file (const gchar *src,
+ const gchar *dest,
+ const gchar *src_encoding);
+gint conv_copy_dir (const gchar *src,
+ const gchar *dest,
+ const gchar *src_encoding);
+
+gchar *conv_filename_from_utf8 (const gchar *utf8_file);
+gchar *conv_filename_to_utf8 (const gchar *fs_file);
+
+#endif /* __CODECONV_H__ */
diff --git a/libsylph/defs.h b/libsylph/defs.h
new file mode 100644
index 00000000..9683c28d
--- /dev/null
+++ b/libsylph/defs.h
@@ -0,0 +1,122 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __DEFS_H__
+#define __DEFS_H__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glibconfig.h>
+
+#ifdef G_OS_WIN32
+# include <glib/gwin32.h>
+#endif
+
+#if HAVE_PATHS_H
+# include <paths.h>
+#endif
+
+#if HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#endif
+
+#define INBOX_DIR "inbox"
+#define OUTBOX_DIR "sent"
+#define QUEUE_DIR "queue"
+#define DRAFT_DIR "draft"
+#define TRASH_DIR "trash"
+#ifdef G_OS_WIN32
+# define RC_DIR "Sylpheed"
+#else
+# define RC_DIR ".sylpheed-2.0"
+#endif
+#define OLD_RC_DIR ".sylpheed"
+#define NEWS_CACHE_DIR "newscache"
+#define IMAP_CACHE_DIR "imapcache"
+#define MIME_TMP_DIR "mimetmp"
+#define COMMON_RC "sylpheedrc"
+#define ACCOUNT_RC "accountrc"
+#define FILTER_RC "filterrc"
+#define FILTER_LIST "filter.xml"
+#define FILTER_HEADER_RC "filterheaderrc"
+#define CUSTOM_HEADER_RC "customheaderrc"
+#define DISPLAY_HEADER_RC "dispheaderrc"
+#define MENU_RC "menurc"
+#define ACTIONS_RC "actionsrc"
+#define COMMAND_HISTORY "command_history"
+#define TEMPLATE_DIR "templates"
+#define TMP_DIR "tmp"
+#define UIDL_DIR "uidl"
+#define NEWSGROUP_LIST ".newsgroup_list"
+#define ADDRESS_BOOK "addressbook.xml"
+#define MANUAL_HTML_INDEX "sylpheed.html"
+#define FAQ_HTML_INDEX "sylpheed-faq.html"
+#define HOMEPAGE_URI "http://sylpheed.good-day.net/"
+#define FOLDER_LIST "folderlist.xml"
+#define CACHE_FILE ".sylpheed_cache"
+#define MARK_FILE ".sylpheed_mark"
+#define CACHE_VERSION 0x21
+#define MARK_VERSION 2
+
+#ifdef G_OS_WIN32
+# define DEFAULT_SIGNATURE "signature.txt"
+#else
+# define DEFAULT_SIGNATURE ".signature"
+#endif
+#define DEFAULT_INC_PATH "/usr/bin/mh/inc"
+#define DEFAULT_INC_PROGRAM "inc"
+/* #define DEFAULT_INC_PATH "/usr/bin/imget" */
+/* #define DEFAULT_INC_PROGRAM "imget" */
+#define DEFAULT_SENDMAIL_CMD "/usr/sbin/sendmail -t -i"
+#define DEFAULT_BROWSER_CMD "mozilla-firefox -remote 'openURL(%s,new-window)'"
+
+#ifdef _PATH_MAILDIR
+# define DEFAULT_SPOOL_PATH _PATH_MAILDIR
+#else
+# define DEFAULT_SPOOL_PATH "/var/spool/mail"
+#endif
+
+#define BUFFSIZE 8192
+
+#ifndef MAXPATHLEN
+# define MAXPATHLEN 4095
+#endif
+
+#define DEFAULT_HEIGHT 460
+#define DEFAULT_FOLDERVIEW_WIDTH 179
+#define DEFAULT_MAINVIEW_WIDTH 600
+#define DEFAULT_SUMMARY_HEIGHT 140
+#define DEFAULT_HEADERVIEW_HEIGHT 40
+#define DEFAULT_COMPOSE_HEIGHT 560
+#define BORDER_WIDTH 2
+#define CTREE_INDENT 18
+#define FOLDER_SPACING 4
+#define MAX_ENTRY_LENGTH 8191
+#define COLOR_DIM 35000
+#define UI_REFRESH_INTERVAL 50000 /* usec */
+#define FOLDER_UPDATE_INTERVAL 1500 /* msec */
+#define PROGRESS_UPDATE_INTERVAL 200 /* msec */
+#define SESSION_TIMEOUT_INTERVAL 60 /* sec */
+#define MAX_HISTORY_SIZE 16
+
+#define DEFAULT_MESSAGE_FONT "Monospace 12"
+
+#endif /* __DEFS_H__ */
diff --git a/libsylph/prefs.c b/libsylph/prefs.c
new file mode 100644
index 00000000..4579df4f
--- /dev/null
+++ b/libsylph/prefs.c
@@ -0,0 +1,465 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "prefs.h"
+#include "codeconv.h"
+#include "utils.h"
+
+typedef enum
+{
+ DUMMY_PARAM
+} DummyEnum;
+
+void prefs_read_config(PrefParam *param, const gchar *label,
+ const gchar *rcfile, const gchar *encoding)
+{
+ FILE *fp;
+ gchar buf[PREFSBUFSIZE];
+ gchar *block_label;
+
+ g_return_if_fail(param != NULL);
+ g_return_if_fail(label != NULL);
+ g_return_if_fail(rcfile != NULL);
+
+ debug_print("Reading configuration...\n");
+
+ prefs_set_default(param);
+
+ if ((fp = g_fopen(rcfile, "rb")) == NULL) {
+ if (ENOENT != errno) FILE_OP_ERROR(rcfile, "fopen");
+ return;
+ }
+
+ block_label = g_strdup_printf("[%s]", label);
+
+ /* search aiming block */
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ gint val;
+
+ if (encoding) {
+ gchar *conv_str;
+
+ conv_str = conv_codeset_strdup
+ (buf, encoding, CS_INTERNAL);
+ if (!conv_str)
+ conv_str = g_strdup(buf);
+ val = strncmp
+ (conv_str, block_label, strlen(block_label));
+ g_free(conv_str);
+ } else
+ val = strncmp(buf, block_label, strlen(block_label));
+ if (val == 0) {
+ debug_print("Found %s\n", block_label);
+ break;
+ }
+ }
+ g_free(block_label);
+
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ strretchomp(buf);
+ /* reached next block */
+ if (buf[0] == '[') break;
+
+ if (encoding) {
+ gchar *conv_str;
+
+ conv_str = conv_codeset_strdup
+ (buf, encoding, CS_INTERNAL);
+ if (!conv_str)
+ conv_str = g_strdup(buf);
+ prefs_config_parse_one_line(param, conv_str);
+ g_free(conv_str);
+ } else
+ prefs_config_parse_one_line(param, buf);
+ }
+
+ debug_print("Finished reading configuration.\n");
+ fclose(fp);
+}
+
+void prefs_config_parse_one_line(PrefParam *param, const gchar *buf)
+{
+ gint i;
+ gint name_len;
+ const gchar *value;
+
+ for (i = 0; param[i].name != NULL; i++) {
+ name_len = strlen(param[i].name);
+ if (g_ascii_strncasecmp(buf, param[i].name, name_len))
+ continue;
+ if (buf[name_len] != '=')
+ continue;
+ value = buf + name_len + 1;
+ /* debug_print("%s = %s\n", param[i].name, value); */
+
+ switch (param[i].type) {
+ case P_STRING:
+ g_free(*((gchar **)param[i].data));
+ *((gchar **)param[i].data) =
+ *value ? g_strdup(value) : NULL;
+ break;
+ case P_INT:
+ *((gint *)param[i].data) =
+ (gint)atoi(value);
+ break;
+ case P_BOOL:
+ *((gboolean *)param[i].data) =
+ (*value == '0' || *value == '\0')
+ ? FALSE : TRUE;
+ break;
+ case P_ENUM:
+ *((DummyEnum *)param[i].data) =
+ (DummyEnum)atoi(value);
+ break;
+ case P_USHORT:
+ *((gushort *)param[i].data) =
+ (gushort)atoi(value);
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+#define TRY(func) \
+if (!(func)) \
+{ \
+ g_warning(_("failed to write configuration to file\n")); \
+ if (orig_fp) fclose(orig_fp); \
+ prefs_file_close_revert(pfile); \
+ g_free(rcpath); \
+ g_free(block_label); \
+ return; \
+} \
+
+void prefs_write_config(PrefParam *param, const gchar *label,
+ const gchar *rcfile)
+{
+ FILE *orig_fp;
+ PrefFile *pfile;
+ gchar *rcpath;
+ gchar buf[PREFSBUFSIZE];
+ gchar *block_label = NULL;
+ gboolean block_matched = FALSE;
+
+ g_return_if_fail(param != NULL);
+ g_return_if_fail(label != NULL);
+ g_return_if_fail(rcfile != NULL);
+
+ rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, rcfile, NULL);
+ if ((orig_fp = g_fopen(rcpath, "rb")) == NULL) {
+ if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
+ }
+
+ if ((pfile = prefs_file_open(rcpath)) == NULL) {
+ g_warning(_("failed to write configuration to file\n"));
+ if (orig_fp) fclose(orig_fp);
+ g_free(rcpath);
+ return;
+ }
+
+ block_label = g_strdup_printf("[%s]", label);
+
+ /* search aiming block */
+ if (orig_fp) {
+ while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
+ gint val;
+
+ val = strncmp(buf, block_label, strlen(block_label));
+ if (val == 0) {
+ debug_print(_("Found %s\n"), block_label);
+ block_matched = TRUE;
+ break;
+ } else
+ TRY(fputs(buf, pfile->fp) != EOF);
+ }
+ }
+
+ TRY(fprintf(pfile->fp, "%s\n", block_label) > 0);
+ g_free(block_label);
+ block_label = NULL;
+
+ /* write all param data to file */
+ TRY(prefs_file_write_param(pfile, param) == 0);
+
+ if (block_matched) {
+ while (fgets(buf, sizeof(buf), orig_fp) != NULL) {
+ /* next block */
+ if (buf[0] == '[') {
+ TRY(fputc('\n', pfile->fp) != EOF &&
+ fputs(buf, pfile->fp) != EOF);
+ break;
+ }
+ }
+ while (fgets(buf, sizeof(buf), orig_fp) != NULL)
+ TRY(fputs(buf, pfile->fp) != EOF);
+ }
+
+ if (orig_fp) fclose(orig_fp);
+ if (prefs_file_close(pfile) < 0)
+ g_warning(_("failed to write configuration to file\n"));
+ g_free(rcpath);
+
+ debug_print(_("Configuration is saved.\n"));
+}
+
+gint prefs_file_write_param(PrefFile *pfile, PrefParam *param)
+{
+ gint i;
+ gchar buf[PREFSBUFSIZE];
+
+ for (i = 0; param[i].name != NULL; i++) {
+ switch (param[i].type) {
+ case P_STRING:
+ g_snprintf(buf, sizeof(buf), "%s=%s\n", param[i].name,
+ *((gchar **)param[i].data) ?
+ *((gchar **)param[i].data) : "");
+ break;
+ case P_INT:
+ g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
+ *((gint *)param[i].data));
+ break;
+ case P_BOOL:
+ g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
+ *((gboolean *)param[i].data));
+ break;
+ case P_ENUM:
+ g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
+ *((DummyEnum *)param[i].data));
+ break;
+ case P_USHORT:
+ g_snprintf(buf, sizeof(buf), "%s=%d\n", param[i].name,
+ *((gushort *)param[i].data));
+ break;
+ default:
+ buf[0] = '\0';
+ }
+
+ if (buf[0] != '\0') {
+ if (fputs(buf, pfile->fp) == EOF) {
+ perror("fputs");
+ return -1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+PrefFile *prefs_file_open(const gchar *path)
+{
+ PrefFile *pfile;
+ gchar *tmppath;
+ FILE *fp;
+
+ g_return_val_if_fail(path != NULL, NULL);
+
+ tmppath = g_strconcat(path, ".tmp", NULL);
+ if ((fp = g_fopen(tmppath, "wb")) == NULL) {
+ FILE_OP_ERROR(tmppath, "fopen");
+ g_free(tmppath);
+ return NULL;
+ }
+
+ if (change_file_mode_rw(fp, tmppath) < 0)
+ FILE_OP_ERROR(tmppath, "chmod");
+
+ g_free(tmppath);
+
+ pfile = g_new(PrefFile, 1);
+ pfile->fp = fp;
+ pfile->path = g_strdup(path);
+
+ return pfile;
+}
+
+gint prefs_file_close(PrefFile *pfile)
+{
+ FILE *fp;
+ gchar *path;
+ gchar *tmppath;
+ gchar *bakpath = NULL;
+
+ g_return_val_if_fail(pfile != NULL, -1);
+
+ fp = pfile->fp;
+ path = pfile->path;
+ g_free(pfile);
+
+ tmppath = g_strconcat(path, ".tmp", NULL);
+ if (fclose(fp) == EOF) {
+ FILE_OP_ERROR(tmppath, "fclose");
+ g_unlink(tmppath);
+ g_free(path);
+ g_free(tmppath);
+ return -1;
+ }
+
+ if (is_file_exist(path)) {
+ bakpath = g_strconcat(path, ".bak", NULL);
+ if (rename_force(path, bakpath) < 0) {
+ FILE_OP_ERROR(path, "rename");
+ g_unlink(tmppath);
+ g_free(path);
+ g_free(tmppath);
+ g_free(bakpath);
+ return -1;
+ }
+ }
+
+ if (rename_force(tmppath, path) < 0) {
+ FILE_OP_ERROR(tmppath, "rename");
+ g_unlink(tmppath);
+ g_free(path);
+ g_free(tmppath);
+ g_free(bakpath);
+ return -1;
+ }
+
+ g_free(path);
+ g_free(tmppath);
+ g_free(bakpath);
+ return 0;
+}
+
+gint prefs_file_close_revert(PrefFile *pfile)
+{
+ gchar *tmppath;
+
+ g_return_val_if_fail(pfile != NULL, -1);
+
+ tmppath = g_strconcat(pfile->path, ".tmp", NULL);
+ fclose(pfile->fp);
+ if (g_unlink(tmppath) < 0)
+ FILE_OP_ERROR(tmppath, "unlink");
+ g_free(tmppath);
+ g_free(pfile->path);
+ g_free(pfile);
+
+ return 0;
+}
+
+void prefs_set_default(PrefParam *param)
+{
+ gint i;
+
+ g_return_if_fail(param != NULL);
+
+ for (i = 0; param[i].name != NULL; i++) {
+ if (!param[i].data) continue;
+
+ switch (param[i].type) {
+ case P_STRING:
+ if (param[i].defval != NULL) {
+ if (!g_ascii_strncasecmp(param[i].defval, "ENV_", 4)) {
+ const gchar *envstr;
+ gchar *tmp = NULL;
+
+ envstr = g_getenv(param[i].defval + 4);
+ if (envstr) {
+ tmp = conv_codeset_strdup
+ (envstr,
+ conv_get_locale_charset_str(),
+ CS_UTF_8);
+ if (!tmp) {
+ g_warning("failed to convert character set.");
+ tmp = g_strdup(envstr);
+ }
+ }
+ *((gchar **)param[i].data) = tmp;
+ } else if (param[i].defval[0] == '~')
+ *((gchar **)param[i].data) =
+ g_strconcat(get_home_dir(),
+ param[i].defval + 1,
+ NULL);
+ else if (param[i].defval[0] != '\0')
+ *((gchar **)param[i].data) =
+ g_strdup(param[i].defval);
+ else
+ *((gchar **)param[i].data) = NULL;
+ } else
+ *((gchar **)param[i].data) = NULL;
+ break;
+ case P_INT:
+ if (param[i].defval != NULL)
+ *((gint *)param[i].data) =
+ (gint)atoi(param[i].defval);
+ else
+ *((gint *)param[i].data) = 0;
+ break;
+ case P_BOOL:
+ if (param[i].defval != NULL) {
+ if (!g_ascii_strcasecmp(param[i].defval, "TRUE"))
+ *((gboolean *)param[i].data) = TRUE;
+ else
+ *((gboolean *)param[i].data) =
+ atoi(param[i].defval) ? TRUE : FALSE;
+ } else
+ *((gboolean *)param[i].data) = FALSE;
+ break;
+ case P_ENUM:
+ if (param[i].defval != NULL)
+ *((DummyEnum*)param[i].data) =
+ (DummyEnum)atoi(param[i].defval);
+ else
+ *((DummyEnum *)param[i].data) = 0;
+ break;
+ case P_USHORT:
+ if (param[i].defval != NULL)
+ *((gushort *)param[i].data) =
+ (gushort)atoi(param[i].defval);
+ else
+ *((gushort *)param[i].data) = 0;
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+void prefs_free(PrefParam *param)
+{
+ gint i;
+
+ g_return_if_fail(param != NULL);
+
+ for (i = 0; param[i].name != NULL; i++) {
+ if (!param[i].data) continue;
+
+ switch (param[i].type) {
+ case P_STRING:
+ g_free(*((gchar **)param[i].data));
+ break;
+ default:
+ break;
+ }
+ }
+}
diff --git a/libsylph/prefs.h b/libsylph/prefs.h
new file mode 100644
index 00000000..f062d1eb
--- /dev/null
+++ b/libsylph/prefs.h
@@ -0,0 +1,80 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __PREFS_H__
+#define __PREFS_H__
+
+#include <glib.h>
+#include <stdio.h>
+
+typedef struct _PrefParam PrefParam;
+typedef struct _PrefFile PrefFile;
+
+#define PREFSBUFSIZE 1024
+
+#define P_WID(wid) ((gpointer *)(wid))
+
+typedef enum
+{
+ P_STRING,
+ P_INT,
+ P_BOOL,
+ P_ENUM,
+ P_USHORT,
+ P_OTHER
+} PrefType;
+
+typedef void (*DataSetFunc) (PrefParam *pparam);
+typedef void (*WidgetSetFunc) (PrefParam *pparam);
+
+struct _PrefParam {
+ gchar *name;
+ gchar *defval;
+ gpointer data;
+ PrefType type;
+ gpointer *widget;
+ DataSetFunc data_set_func;
+ WidgetSetFunc widget_set_func;
+};
+
+struct _PrefFile {
+ FILE *fp;
+ gchar *path;
+};
+
+void prefs_read_config (PrefParam *param,
+ const gchar *label,
+ const gchar *rcfile,
+ const gchar *encoding);
+void prefs_config_parse_one_line(PrefParam *param,
+ const gchar *buf);
+void prefs_write_config (PrefParam *param,
+ const gchar *label,
+ const gchar *rcfile);
+
+PrefFile *prefs_file_open (const gchar *path);
+gint prefs_file_write_param (PrefFile *pfile,
+ PrefParam *param);
+gint prefs_file_close (PrefFile *pfile);
+gint prefs_file_close_revert (PrefFile *pfile);
+
+void prefs_set_default (PrefParam *param);
+void prefs_free (PrefParam *param);
+
+#endif /* __PREFS_H__ */
diff --git a/libsylph/quoted-printable.c b/libsylph/quoted-printable.c
new file mode 100644
index 00000000..cea0b704
--- /dev/null
+++ b/libsylph/quoted-printable.c
@@ -0,0 +1,232 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2003 Hiroyuki Yamamoto
+ *
+ * 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 <glib.h>
+#include <ctype.h>
+
+static gboolean get_hex_value(guchar *out, gchar c1, gchar c2);
+static void get_hex_str(gchar *out, guchar ch);
+
+#define MAX_LINELEN 76
+
+#define IS_LBREAK(p) \
+ (*(p) == '\0' || *(p) == '\n' || (*(p) == '\r' && *((p) + 1) == '\n'))
+
+#define SOFT_LBREAK_IF_REQUIRED(n) \
+ if (len + (n) > MAX_LINELEN || \
+ (len + (n) == MAX_LINELEN && (!IS_LBREAK(inp + 1)))) { \
+ *outp++ = '='; \
+ *outp++ = '\n'; \
+ len = 0; \
+ }
+
+void qp_encode_line(gchar *out, const guchar *in)
+{
+ const guchar *inp = in;
+ gchar *outp = out;
+ guchar ch;
+ gint len = 0;
+
+ while (*inp != '\0') {
+ ch = *inp;
+
+ if (IS_LBREAK(inp)) {
+ *outp++ = '\n';
+ len = 0;
+ if (*inp == '\r')
+ inp++;
+ inp++;
+ } else if (ch == '\t' || ch == ' ') {
+ if (IS_LBREAK(inp + 1)) {
+ SOFT_LBREAK_IF_REQUIRED(3);
+ *outp++ = '=';
+ get_hex_str(outp, ch);
+ outp += 2;
+ len += 3;
+ inp++;
+ } else {
+ SOFT_LBREAK_IF_REQUIRED(1);
+ *outp++ = *inp++;
+ len++;
+ }
+ } else if ((ch >= 33 && ch <= 60) || (ch >= 62 && ch <= 126)) {
+ SOFT_LBREAK_IF_REQUIRED(1);
+ *outp++ = *inp++;
+ len++;
+ } else {
+ SOFT_LBREAK_IF_REQUIRED(3);
+ *outp++ = '=';
+ get_hex_str(outp, ch);
+ outp += 2;
+ len += 3;
+ inp++;
+ }
+ }
+
+ if (len > 0)
+ *outp++ = '\n';
+
+ *outp = '\0';
+}
+
+gint qp_decode_line(gchar *str)
+{
+ gchar *inp = str, *outp = str;
+
+ while (*inp != '\0') {
+ if (*inp == '=') {
+ if (inp[1] && inp[2] &&
+ get_hex_value((guchar *)outp, inp[1], inp[2])
+ == TRUE) {
+ inp += 3;
+ } else if (inp[1] == '\0' || g_ascii_isspace(inp[1])) {
+ /* soft line break */
+ break;
+ } else {
+ /* broken QP string */
+ *outp = *inp++;
+ }
+ } else {
+ *outp = *inp++;
+ }
+ outp++;
+ }
+
+ *outp = '\0';
+
+ return outp - str;
+}
+
+gint qp_decode_q_encoding(guchar *out, const gchar *in, gint inlen)
+{
+ const gchar *inp = in;
+ guchar *outp = out;
+
+ if (inlen < 0)
+ inlen = G_MAXINT;
+
+ while (inp - in < inlen && *inp != '\0') {
+ if (*inp == '=' && inp + 3 - in <= inlen) {
+ if (get_hex_value(outp, inp[1], inp[2]) == TRUE) {
+ inp += 3;
+ } else {
+ *outp = *inp++;
+ }
+ } else if (*inp == '_') {
+ *outp = ' ';
+ inp++;
+ } else {
+ *outp = *inp++;
+ }
+ outp++;
+ }
+
+ *outp = '\0';
+
+ return outp - out;
+}
+
+gint qp_get_q_encoding_len(const guchar *str)
+{
+ const guchar *inp = str;
+ gint len = 0;
+
+ while (*inp != '\0') {
+ if (*inp == 0x20)
+ len++;
+ else if (*inp == '=' || *inp == '?' || *inp == '_' ||
+ *inp < 32 || *inp > 127 || g_ascii_isspace(*inp))
+ len += 3;
+ else
+ len++;
+
+ inp++;
+ }
+
+ return len;
+}
+
+void qp_q_encode(gchar *out, const guchar *in)
+{
+ const guchar *inp = in;
+ gchar *outp = out;
+
+ while (*inp != '\0') {
+ if (*inp == 0x20)
+ *outp++ = '_';
+ else if (*inp == '=' || *inp == '?' || *inp == '_' ||
+ *inp < 32 || *inp > 127 || g_ascii_isspace(*inp)) {
+ *outp++ = '=';
+ get_hex_str(outp, *inp);
+ outp += 2;
+ } else
+ *outp++ = *inp;
+
+ inp++;
+ }
+
+ *outp = '\0';
+}
+
+#define HEX_TO_INT(val, hex) \
+{ \
+ gchar c = hex; \
+ \
+ if ('0' <= c && c <= '9') { \
+ val = c - '0'; \
+ } else if ('a' <= c && c <= 'f') { \
+ val = c - 'a' + 10; \
+ } else if ('A' <= c && c <= 'F') { \
+ val = c - 'A' + 10; \
+ } else { \
+ val = -1; \
+ } \
+}
+
+static gboolean get_hex_value(guchar *out, gchar c1, gchar c2)
+{
+ gint hi, lo;
+
+ HEX_TO_INT(hi, c1);
+ HEX_TO_INT(lo, c2);
+
+ if (hi == -1 || lo == -1)
+ return FALSE;
+
+ *out = (hi << 4) + lo;
+ return TRUE;
+}
+
+#define INT_TO_HEX(hex, val) \
+{ \
+ if ((val) < 10) \
+ hex = '0' + (val); \
+ else \
+ hex = 'A' + (val) - 10; \
+}
+
+static void get_hex_str(gchar *out, guchar ch)
+{
+ gchar hex;
+
+ INT_TO_HEX(hex, ch >> 4);
+ *out++ = hex;
+ INT_TO_HEX(hex, ch & 0x0f);
+ *out++ = hex;
+}
diff --git a/libsylph/quoted-printable.h b/libsylph/quoted-printable.h
new file mode 100644
index 00000000..e5abf4f7
--- /dev/null
+++ b/libsylph/quoted-printable.h
@@ -0,0 +1,36 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2003 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __QUOTED_PRINTABLE_H__
+#define __QUOTED_PRINTABLE_H__
+
+#include <glib.h>
+
+void qp_encode_line (gchar *out,
+ const guchar *in);
+gint qp_decode_line (gchar *str);
+
+gint qp_decode_q_encoding (guchar *out,
+ const gchar *in,
+ gint inlen);
+gint qp_get_q_encoding_len (const guchar *str);
+void qp_q_encode (gchar *out,
+ const guchar *in);
+
+#endif /* __QUOTED_PRINTABLE_H__ */
diff --git a/libsylph/session.c b/libsylph/session.c
new file mode 100644
index 00000000..6e7fa4e9
--- /dev/null
+++ b/libsylph/session.c
@@ -0,0 +1,793 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "defs.h"
+
+#include <glib.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+
+#include "session.h"
+#include "utils.h"
+
+static gint session_connect_cb (SockInfo *sock,
+ gpointer data);
+static gint session_close (Session *session);
+
+static gboolean session_timeout_cb (gpointer data);
+
+static gboolean session_recv_msg_idle_cb (gpointer data);
+static gboolean session_recv_data_idle_cb (gpointer data);
+
+static gboolean session_read_msg_cb (SockInfo *source,
+ GIOCondition condition,
+ gpointer data);
+static gboolean session_read_data_cb (SockInfo *source,
+ GIOCondition condition,
+ gpointer data);
+static gboolean session_write_msg_cb (SockInfo *source,
+ GIOCondition condition,
+ gpointer data);
+static gboolean session_write_data_cb (SockInfo *source,
+ GIOCondition condition,
+ gpointer data);
+
+
+void session_init(Session *session)
+{
+ session->type = SESSION_UNKNOWN;
+ session->sock = NULL;
+ session->server = NULL;
+ session->port = 0;
+#if USE_SSL
+ session->ssl_type = SSL_NONE;
+#endif
+ session->nonblocking = TRUE;
+ session->state = SESSION_READY;
+ session->last_access_time = time(NULL);
+
+ g_get_current_time(&session->tv_prev);
+
+ session->conn_id = 0;
+
+ session->io_tag = 0;
+
+ session->read_buf_p = session->read_buf;
+ session->read_buf_len = 0;
+
+ session->read_msg_buf = g_string_sized_new(1024);
+ session->read_data_buf = g_byte_array_new();
+
+ session->write_buf = NULL;
+ session->write_buf_p = NULL;
+ session->write_buf_len = 0;
+
+ session->write_data = NULL;
+ session->write_data_p = NULL;
+ session->write_data_len = 0;
+
+ session->timeout_tag = 0;
+ session->timeout_interval = 0;
+
+ session->data = NULL;
+}
+
+gint session_connect(Session *session, const gchar *server, gushort port)
+{
+#ifdef G_OS_UNIX
+ session->server = g_strdup(server);
+ session->port = port;
+
+ session->conn_id = sock_connect_async(server, port, session_connect_cb,
+ session);
+ if (session->conn_id < 0) {
+ g_warning("can't connect to server.");
+ session_close(session);
+ return -1;
+ }
+
+ return 0;
+#else
+ SockInfo *sock;
+
+ session->server = g_strdup(server);
+ session->port = port;
+
+ sock = sock_connect(server, port);
+ if (sock == NULL) {
+ g_warning("can't connect to server.");
+ session_close(session);
+ return -1;
+ }
+
+ return session_connect_cb(sock, session);
+#endif
+}
+
+static gint session_connect_cb(SockInfo *sock, gpointer data)
+{
+ Session *session = SESSION(data);
+
+ session->conn_id = 0;
+
+ if (!sock) {
+ g_warning("can't connect to server.");
+ session->state = SESSION_ERROR;
+ return -1;
+ }
+
+ session->sock = sock;
+
+#if USE_SSL
+ if (session->ssl_type == SSL_TUNNEL) {
+ sock_set_nonblocking_mode(sock, FALSE);
+ if (!ssl_init_socket(sock)) {
+ g_warning("can't initialize SSL.");
+ session->state = SESSION_ERROR;
+ return -1;
+ }
+ }
+#endif
+
+ sock_set_nonblocking_mode(sock, session->nonblocking);
+
+ debug_print("session (%p): connected\n", session);
+
+ session->state = SESSION_RECV;
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ session_read_msg_cb,
+ session);
+
+ return 0;
+}
+
+gint session_disconnect(Session *session)
+{
+ session_close(session);
+ return 0;
+}
+
+void session_destroy(Session *session)
+{
+ g_return_if_fail(session != NULL);
+ g_return_if_fail(session->destroy != NULL);
+
+ session_close(session);
+ session->destroy(session);
+ g_free(session->server);
+ g_string_free(session->read_msg_buf, TRUE);
+ g_byte_array_free(session->read_data_buf, TRUE);
+ g_free(session->read_data_terminator);
+ g_free(session->write_buf);
+
+ debug_print("session (%p): destroyed\n", session);
+
+ g_free(session);
+}
+
+gboolean session_is_connected(Session *session)
+{
+ return (session->state == SESSION_READY ||
+ session->state == SESSION_SEND ||
+ session->state == SESSION_RECV);
+}
+
+void session_set_access_time(Session *session)
+{
+ session->last_access_time = time(NULL);
+}
+
+void session_set_timeout(Session *session, guint interval)
+{
+ if (session->timeout_tag > 0)
+ g_source_remove(session->timeout_tag);
+
+ session->timeout_interval = interval;
+ if (interval > 0)
+ session->timeout_tag =
+ g_timeout_add(interval, session_timeout_cb, session);
+ else
+ session->timeout_tag = 0;
+}
+
+static gboolean session_timeout_cb(gpointer data)
+{
+ Session *session = SESSION(data);
+
+ g_warning("session timeout.\n");
+
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ session->timeout_tag = 0;
+ session->state = SESSION_TIMEOUT;
+
+ return FALSE;
+}
+
+void session_set_recv_message_notify(Session *session,
+ RecvMsgNotify notify_func, gpointer data)
+{
+ session->recv_msg_notify = notify_func;
+ session->recv_msg_notify_data = data;
+}
+
+void session_set_recv_data_progressive_notify
+ (Session *session,
+ RecvDataProgressiveNotify notify_func,
+ gpointer data)
+{
+ session->recv_data_progressive_notify = notify_func,
+ session->recv_data_progressive_notify_data = data;
+}
+
+void session_set_recv_data_notify(Session *session, RecvDataNotify notify_func,
+ gpointer data)
+{
+ session->recv_data_notify = notify_func;
+ session->recv_data_notify_data = data;
+}
+
+void session_set_send_data_progressive_notify
+ (Session *session,
+ SendDataProgressiveNotify notify_func,
+ gpointer data)
+{
+ session->send_data_progressive_notify = notify_func;
+ session->send_data_progressive_notify_data = data;
+}
+
+void session_set_send_data_notify(Session *session, SendDataNotify notify_func,
+ gpointer data)
+{
+ session->send_data_notify = notify_func;
+ session->send_data_notify_data = data;
+}
+
+static gint session_close(Session *session)
+{
+ g_return_val_if_fail(session != NULL, -1);
+
+#ifdef G_OS_UNIX
+ if (session->conn_id > 0) {
+ sock_connect_async_cancel(session->conn_id);
+ session->conn_id = 0;
+ debug_print("session (%p): connection cancelled\n", session);
+ }
+#endif
+
+ session_set_timeout(session, 0);
+
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ if (session->sock) {
+ sock_close(session->sock);
+ session->sock = NULL;
+ session->state = SESSION_DISCONNECTED;
+ debug_print("session (%p): closed\n", session);
+ }
+
+ return 0;
+}
+
+#if USE_SSL
+gint session_start_tls(Session *session)
+{
+ gboolean nb_mode;
+
+ nb_mode = sock_is_nonblocking_mode(session->sock);
+
+ if (nb_mode)
+ sock_set_nonblocking_mode(session->sock, FALSE);
+
+ if (!ssl_init_socket_with_method(session->sock, SSL_METHOD_TLSv1)) {
+ g_warning("can't start TLS session.\n");
+ if (nb_mode)
+ sock_set_nonblocking_mode(session->sock, TRUE);
+ return -1;
+ }
+
+ if (nb_mode)
+ sock_set_nonblocking_mode(session->sock, session->nonblocking);
+
+ return 0;
+}
+#endif
+
+gint session_send_msg(Session *session, SessionMsgType type, const gchar *msg)
+{
+ gboolean ret;
+
+ g_return_val_if_fail(session->write_buf == NULL, -1);
+ g_return_val_if_fail(msg != NULL, -1);
+ g_return_val_if_fail(msg[0] != '\0', -1);
+
+ session->state = SESSION_SEND;
+ session->write_buf = g_strconcat(msg, "\r\n", NULL);
+ session->write_buf_p = session->write_buf;
+ session->write_buf_len = strlen(msg) + 2;
+
+ ret = session_write_msg_cb(session->sock, G_IO_OUT, session);
+
+ if (ret == TRUE)
+ session->io_tag = sock_add_watch(session->sock, G_IO_OUT,
+ session_write_msg_cb, session);
+ else if (session->state == SESSION_ERROR)
+ return -1;
+
+ return 0;
+}
+
+gint session_recv_msg(Session *session)
+{
+ g_return_val_if_fail(session->read_msg_buf->len == 0, -1);
+
+ session->state = SESSION_RECV;
+
+ if (session->read_buf_len > 0)
+ g_idle_add(session_recv_msg_idle_cb, session);
+ else
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ session_read_msg_cb, session);
+
+ return 0;
+}
+
+static gboolean session_recv_msg_idle_cb(gpointer data)
+{
+ Session *session = SESSION(data);
+ gboolean ret;
+
+ ret = session_read_msg_cb(session->sock, G_IO_IN, session);
+
+ if (ret == TRUE)
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ session_read_msg_cb, session);
+
+ return FALSE;
+}
+
+gint session_send_data(Session *session, const guchar *data, guint size)
+{
+ gboolean ret;
+
+ g_return_val_if_fail(session->write_data == NULL, -1);
+ g_return_val_if_fail(data != NULL, -1);
+ g_return_val_if_fail(size != 0, -1);
+
+ session->state = SESSION_SEND;
+
+ session->write_data = data;
+ session->write_data_p = session->write_data;
+ session->write_data_len = size;
+ g_get_current_time(&session->tv_prev);
+
+ ret = session_write_data_cb(session->sock, G_IO_OUT, session);
+
+ if (ret == TRUE)
+ session->io_tag = sock_add_watch(session->sock, G_IO_OUT,
+ session_write_data_cb,
+ session);
+ else if (session->state == SESSION_ERROR)
+ return -1;
+
+ return 0;
+}
+
+gint session_recv_data(Session *session, guint size, const gchar *terminator)
+{
+ g_return_val_if_fail(session->read_data_buf->len == 0, -1);
+
+ session->state = SESSION_RECV;
+
+ g_free(session->read_data_terminator);
+ session->read_data_terminator = g_strdup(terminator);
+ g_get_current_time(&session->tv_prev);
+
+ if (session->read_buf_len > 0)
+ g_idle_add(session_recv_data_idle_cb, session);
+ else
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ session_read_data_cb, session);
+
+ return 0;
+}
+
+static gboolean session_recv_data_idle_cb(gpointer data)
+{
+ Session *session = SESSION(data);
+ gboolean ret;
+
+ ret = session_read_data_cb(session->sock, G_IO_IN, session);
+
+ if (ret == TRUE)
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ session_read_data_cb, session);
+
+ return FALSE;
+}
+
+static gboolean session_read_msg_cb(SockInfo *source, GIOCondition condition,
+ gpointer data)
+{
+ Session *session = SESSION(data);
+ gchar buf[SESSION_BUFFSIZE];
+ gint line_len;
+ gchar *newline;
+ gchar *msg;
+ gint ret;
+
+ g_return_val_if_fail(condition == G_IO_IN, FALSE);
+
+ session_set_timeout(session, session->timeout_interval);
+
+ if (session->read_buf_len == 0) {
+ gint read_len;
+
+ read_len = sock_read(session->sock, session->read_buf,
+ SESSION_BUFFSIZE - 1);
+
+ if (read_len == 0) {
+ g_warning("sock_read: received EOF\n");
+ session->state = SESSION_EOF;
+ return FALSE;
+ }
+
+ if (read_len < 0) {
+ switch (errno) {
+ case EAGAIN:
+ return TRUE;
+ default:
+ g_warning("sock_read: %s\n", g_strerror(errno));
+ session->state = SESSION_ERROR;
+ return FALSE;
+ }
+ }
+
+ session->read_buf_len = read_len;
+ }
+
+ if ((newline = memchr(session->read_buf_p, '\n', session->read_buf_len))
+ != NULL)
+ line_len = newline - session->read_buf_p + 1;
+ else
+ line_len = session->read_buf_len;
+
+ if (line_len == 0)
+ return TRUE;
+
+ memcpy(buf, session->read_buf_p, line_len);
+ buf[line_len] = '\0';
+
+ g_string_append(session->read_msg_buf, buf);
+
+ session->read_buf_len -= line_len;
+ if (session->read_buf_len == 0)
+ session->read_buf_p = session->read_buf;
+ else
+ session->read_buf_p += line_len;
+
+ /* incomplete read */
+ if (buf[line_len - 1] != '\n')
+ return TRUE;
+
+ /* complete */
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ /* callback */
+ msg = g_strdup(session->read_msg_buf->str);
+ strretchomp(msg);
+ g_string_truncate(session->read_msg_buf, 0);
+
+ ret = session->recv_msg(session, msg);
+ session->recv_msg_notify(session, msg, session->recv_msg_notify_data);
+
+ g_free(msg);
+
+ if (ret < 0)
+ session->state = SESSION_ERROR;
+
+ return FALSE;
+}
+
+static gboolean session_read_data_cb(SockInfo *source, GIOCondition condition,
+ gpointer data)
+{
+ Session *session = SESSION(data);
+ GByteArray *data_buf;
+ gint terminator_len;
+ gboolean complete = FALSE;
+ guint data_len;
+ gint ret;
+
+ g_return_val_if_fail(condition == G_IO_IN, FALSE);
+
+ session_set_timeout(session, session->timeout_interval);
+
+ if (session->read_buf_len == 0) {
+ gint read_len;
+
+ read_len = sock_read(session->sock, session->read_buf,
+ SESSION_BUFFSIZE);
+
+ if (read_len == 0) {
+ g_warning("sock_read: received EOF\n");
+ session->state = SESSION_EOF;
+ return FALSE;
+ }
+
+ if (read_len < 0) {
+ switch (errno) {
+ case EAGAIN:
+ return TRUE;
+ default:
+ g_warning("sock_read: %s\n", g_strerror(errno));
+ session->state = SESSION_ERROR;
+ return FALSE;
+ }
+ }
+
+ session->read_buf_len = read_len;
+ }
+
+ data_buf = session->read_data_buf;
+ terminator_len = strlen(session->read_data_terminator);
+
+ if (session->read_buf_len == 0)
+ return TRUE;
+
+ g_byte_array_append(data_buf, session->read_buf_p,
+ session->read_buf_len);
+
+ session->read_buf_len = 0;
+ session->read_buf_p = session->read_buf;
+
+ /* check if data is terminated */
+ if (data_buf->len >= terminator_len) {
+ if (memcmp(data_buf->data, session->read_data_terminator,
+ terminator_len) == 0)
+ complete = TRUE;
+ else if (data_buf->len >= terminator_len + 2 &&
+ memcmp(data_buf->data + data_buf->len -
+ (terminator_len + 2), "\r\n", 2) == 0 &&
+ memcmp(data_buf->data + data_buf->len -
+ terminator_len, session->read_data_terminator,
+ terminator_len) == 0)
+ complete = TRUE;
+ }
+
+ /* incomplete read */
+ if (!complete) {
+ GTimeVal tv_cur;
+
+ g_get_current_time(&tv_cur);
+ if (tv_cur.tv_sec - session->tv_prev.tv_sec > 0 ||
+ tv_cur.tv_usec - session->tv_prev.tv_usec >
+ UI_REFRESH_INTERVAL) {
+ session->recv_data_progressive_notify
+ (session, data_buf->len, 0,
+ session->recv_data_progressive_notify_data);
+ g_get_current_time(&session->tv_prev);
+ }
+ return TRUE;
+ }
+
+ /* complete */
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ data_len = data_buf->len - terminator_len;
+
+ /* callback */
+ ret = session->recv_data_finished(session, (gchar *)data_buf->data,
+ data_len);
+
+ g_byte_array_set_size(data_buf, 0);
+
+ session->recv_data_notify(session, data_len,
+ session->recv_data_notify_data);
+
+ if (ret < 0)
+ session->state = SESSION_ERROR;
+
+ return FALSE;
+}
+
+static gint session_write_buf(Session *session)
+{
+ gint write_len;
+ gint to_write_len;
+
+ g_return_val_if_fail(session->write_buf != NULL, -1);
+ g_return_val_if_fail(session->write_buf_p != NULL, -1);
+ g_return_val_if_fail(session->write_buf_len > 0, -1);
+
+ to_write_len = session->write_buf_len -
+ (session->write_buf_p - session->write_buf);
+ to_write_len = MIN(to_write_len, SESSION_BUFFSIZE);
+
+ write_len = sock_write(session->sock, session->write_buf_p,
+ to_write_len);
+
+ if (write_len < 0) {
+ switch (errno) {
+ case EAGAIN:
+ write_len = 0;
+ break;
+ default:
+ g_warning("sock_write: %s\n", g_strerror(errno));
+ session->state = SESSION_ERROR;
+ return -1;
+ }
+ }
+
+ /* incomplete write */
+ if (session->write_buf_p - session->write_buf + write_len <
+ session->write_buf_len) {
+ session->write_buf_p += write_len;
+ return 1;
+ }
+
+ g_free(session->write_buf);
+ session->write_buf = NULL;
+ session->write_buf_p = NULL;
+ session->write_buf_len = 0;
+
+ return 0;
+}
+
+static gint session_write_data(Session *session)
+{
+ gint write_len;
+ gint to_write_len;
+
+ g_return_val_if_fail(session->write_data != NULL, -1);
+ g_return_val_if_fail(session->write_data_p != NULL, -1);
+ g_return_val_if_fail(session->write_data_len > 0, -1);
+
+ to_write_len = session->write_data_len -
+ (session->write_data_p - session->write_data);
+ to_write_len = MIN(to_write_len, SESSION_BUFFSIZE);
+
+ write_len = sock_write(session->sock, session->write_data_p,
+ to_write_len);
+
+ if (write_len < 0) {
+ switch (errno) {
+ case EAGAIN:
+ write_len = 0;
+ break;
+ default:
+ g_warning("sock_write: %s\n", g_strerror(errno));
+ session->state = SESSION_ERROR;
+ return -1;
+ }
+ }
+
+ /* incomplete write */
+ if (session->write_data_p - session->write_data + write_len <
+ session->write_data_len) {
+ session->write_data_p += write_len;
+ return 1;
+ }
+
+ session->write_data = NULL;
+ session->write_data_p = NULL;
+ session->write_data_len = 0;
+
+ return 0;
+}
+
+static gboolean session_write_msg_cb(SockInfo *source, GIOCondition condition,
+ gpointer data)
+{
+ Session *session = SESSION(data);
+ gint ret;
+
+ g_return_val_if_fail(condition == G_IO_OUT, FALSE);
+ g_return_val_if_fail(session->write_buf != NULL, FALSE);
+ g_return_val_if_fail(session->write_buf_p != NULL, FALSE);
+ g_return_val_if_fail(session->write_buf_len > 0, FALSE);
+
+ ret = session_write_buf(session);
+
+ if (ret < 0) {
+ session->state = SESSION_ERROR;
+ return FALSE;
+ } else if (ret > 0)
+ return TRUE;
+
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ session_recv_msg(session);
+
+ return FALSE;
+}
+
+static gboolean session_write_data_cb(SockInfo *source,
+ GIOCondition condition, gpointer data)
+{
+ Session *session = SESSION(data);
+ guint write_data_len;
+ gint ret;
+
+ g_return_val_if_fail(condition == G_IO_OUT, FALSE);
+ g_return_val_if_fail(session->write_data != NULL, FALSE);
+ g_return_val_if_fail(session->write_data_p != NULL, FALSE);
+ g_return_val_if_fail(session->write_data_len > 0, FALSE);
+
+ write_data_len = session->write_data_len;
+
+ ret = session_write_data(session);
+
+ if (ret < 0) {
+ session->state = SESSION_ERROR;
+ return FALSE;
+ } else if (ret > 0) {
+ GTimeVal tv_cur;
+
+ g_get_current_time(&tv_cur);
+ if (tv_cur.tv_sec - session->tv_prev.tv_sec > 0 ||
+ tv_cur.tv_usec - session->tv_prev.tv_usec >
+ UI_REFRESH_INTERVAL) {
+ session_set_timeout(session, session->timeout_interval);
+ session->send_data_progressive_notify
+ (session,
+ session->write_data_p - session->write_data,
+ write_data_len,
+ session->send_data_progressive_notify_data);
+ g_get_current_time(&session->tv_prev);
+ }
+ return TRUE;
+ }
+
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ /* callback */
+ ret = session->send_data_finished(session, write_data_len);
+ session->send_data_notify(session, write_data_len,
+ session->send_data_notify_data);
+
+ return FALSE;
+}
diff --git a/libsylph/session.h b/libsylph/session.h
new file mode 100644
index 00000000..9ed0eaf4
--- /dev/null
+++ b/libsylph/session.h
@@ -0,0 +1,205 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __SESSION_H__
+#define __SESSION_H__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+
+#include <time.h>
+#include <unistd.h>
+
+#include "socket.h"
+
+#define SESSION_BUFFSIZE 4096
+
+typedef struct _Session Session;
+
+#define SESSION(obj) ((Session *)obj)
+
+typedef enum {
+ SESSION_UNKNOWN,
+ SESSION_IMAP,
+ SESSION_NEWS,
+ SESSION_SMTP,
+ SESSION_POP3
+} SessionType;
+
+typedef enum {
+ SESSION_READY,
+ SESSION_SEND,
+ SESSION_RECV,
+ SESSION_EOF,
+ SESSION_TIMEOUT,
+ SESSION_ERROR,
+ SESSION_DISCONNECTED
+} SessionState;
+
+typedef enum
+{
+ SESSION_MSG_NORMAL,
+ SESSION_MSG_SEND_DATA,
+ SESSION_MSG_RECV_DATA,
+ SESSION_MSG_CONTROL,
+ SESSION_MSG_ERROR,
+ SESSION_MSG_UNKNOWN
+} SessionMsgType;
+
+typedef gint (*RecvMsgNotify) (Session *session,
+ const gchar *msg,
+ gpointer user_data);
+typedef gint (*RecvDataProgressiveNotify) (Session *session,
+ guint cur_len,
+ guint total_len,
+ gpointer user_data);
+typedef gint (*RecvDataNotify) (Session *session,
+ guint len,
+ gpointer user_data);
+typedef gint (*SendDataProgressiveNotify) (Session *session,
+ guint cur_len,
+ guint total_len,
+ gpointer user_data);
+typedef gint (*SendDataNotify) (Session *session,
+ guint len,
+ gpointer user_data);
+
+struct _Session
+{
+ SessionType type;
+
+ SockInfo *sock;
+
+ gchar *server;
+ gushort port;
+
+#if USE_SSL
+ SSLType ssl_type;
+#endif
+
+ gboolean nonblocking;
+
+ SessionState state;
+
+ time_t last_access_time;
+ GTimeVal tv_prev;
+
+ gint conn_id;
+
+ gint io_tag;
+
+ gchar read_buf[SESSION_BUFFSIZE];
+ gchar *read_buf_p;
+ gint read_buf_len;
+
+ GString *read_msg_buf;
+ GByteArray *read_data_buf;
+ gchar *read_data_terminator;
+
+ /* buffer for short messages */
+ gchar *write_buf;
+ gchar *write_buf_p;
+ gint write_buf_len;
+
+ /* buffer for large data */
+ const guchar *write_data;
+ const guchar *write_data_p;
+ gint write_data_len;
+
+ guint timeout_tag;
+ guint timeout_interval;
+
+ gpointer data;
+
+ /* virtual methods to parse server responses */
+ gint (*recv_msg) (Session *session,
+ const gchar *msg);
+
+ gint (*send_data_finished) (Session *session,
+ guint len);
+ gint (*recv_data_finished) (Session *session,
+ guchar *data,
+ guint len);
+
+ void (*destroy) (Session *session);
+
+ /* notification functions */
+ RecvMsgNotify recv_msg_notify;
+ RecvDataProgressiveNotify recv_data_progressive_notify;
+ RecvDataNotify recv_data_notify;
+ SendDataProgressiveNotify send_data_progressive_notify;
+ SendDataNotify send_data_notify;
+
+ gpointer recv_msg_notify_data;
+ gpointer recv_data_progressive_notify_data;
+ gpointer recv_data_notify_data;
+ gpointer send_data_progressive_notify_data;
+ gpointer send_data_notify_data;
+};
+
+void session_init (Session *session);
+gint session_connect (Session *session,
+ const gchar *server,
+ gushort port);
+gint session_disconnect (Session *session);
+void session_destroy (Session *session);
+gboolean session_is_connected (Session *session);
+
+void session_set_access_time (Session *session);
+
+void session_set_timeout (Session *session,
+ guint interval);
+
+void session_set_recv_message_notify (Session *session,
+ RecvMsgNotify notify_func,
+ gpointer data);
+void session_set_recv_data_progressive_notify
+ (Session *session,
+ RecvDataProgressiveNotify notify_func,
+ gpointer data);
+void session_set_recv_data_notify (Session *session,
+ RecvDataNotify notify_func,
+ gpointer data);
+void session_set_send_data_progressive_notify
+ (Session *session,
+ SendDataProgressiveNotify notify_func,
+ gpointer data);
+void session_set_send_data_notify (Session *session,
+ SendDataNotify notify_func,
+ gpointer data);
+
+#if USE_SSL
+gint session_start_tls (Session *session);
+#endif
+
+gint session_send_msg (Session *session,
+ SessionMsgType type,
+ const gchar *msg);
+gint session_recv_msg (Session *session);
+gint session_send_data (Session *session,
+ const guchar *data,
+ guint size);
+gint session_recv_data (Session *session,
+ guint size,
+ const gchar *terminator);
+
+#endif /* __SESSION_H__ */
diff --git a/libsylph/socket.c b/libsylph/socket.c
new file mode 100644
index 00000000..17063ab1
--- /dev/null
+++ b/libsylph/socket.c
@@ -0,0 +1,1397 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#ifdef G_OS_WIN32
+# include <winsock2.h>
+#else
+# if HAVE_SYS_WAIT_H
+# include <sys/wait.h>
+# endif
+# include <sys/socket.h>
+# include <sys/un.h>
+# include <netinet/in.h>
+# include <arpa/inet.h>
+# include <netdb.h>
+#endif /* G_OS_WIN32 */
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+#include <setjmp.h>
+#if HAVE_SYS_SELECT_H
+# include <sys/select.h>
+#endif
+
+#include "socket.h"
+#if USE_SSL
+# include "ssl.h"
+#endif
+
+#define BUFFSIZE 8192
+
+typedef gint (*SockAddrFunc) (GList *addr_list,
+ gpointer data);
+
+typedef struct _SockConnectData SockConnectData;
+typedef struct _SockLookupData SockLookupData;
+typedef struct _SockAddrData SockAddrData;
+typedef struct _SockSource SockSource;
+
+struct _SockConnectData {
+ gint id;
+ gchar *hostname;
+ gushort port;
+ GList *addr_list;
+ GList *cur_addr;
+ SockLookupData *lookup_data;
+ GIOChannel *channel;
+ guint io_tag;
+ SockConnectFunc func;
+ gpointer data;
+};
+
+struct _SockLookupData {
+ gchar *hostname;
+ pid_t child_pid;
+ GIOChannel *channel;
+ guint io_tag;
+ SockAddrFunc func;
+ gpointer data;
+};
+
+struct _SockAddrData {
+ gint family;
+ gint socktype;
+ gint protocol;
+ gint addr_len;
+ struct sockaddr *addr;
+};
+
+struct _SockSource {
+ GSource parent;
+ SockInfo *sock;
+};
+
+static guint io_timeout = 60;
+
+static GList *sock_connect_data_list = NULL;
+
+static gboolean sock_prepare (GSource *source,
+ gint *timeout);
+static gboolean sock_check (GSource *source);
+static gboolean sock_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data);
+
+GSourceFuncs sock_watch_funcs = {
+ sock_prepare,
+ sock_check,
+ sock_dispatch,
+ NULL
+};
+
+static gint sock_connect_with_timeout (gint sock,
+ const struct sockaddr *serv_addr,
+ gint addrlen,
+ guint timeout_secs);
+
+#ifndef INET6
+static gint sock_connect_by_hostname (gint sock,
+ const gchar *hostname,
+ gushort port);
+#else
+static gint sock_connect_by_getaddrinfo (const gchar *hostname,
+ gushort port);
+#endif
+
+#ifdef G_OS_UNIX
+static void sock_address_list_free (GList *addr_list);
+
+static gboolean sock_connect_async_cb (GIOChannel *source,
+ GIOCondition condition,
+ gpointer data);
+static gint sock_connect_async_get_address_info_cb
+ (GList *addr_list,
+ gpointer data);
+
+static gint sock_connect_address_list_async (SockConnectData *conn_data);
+
+static gboolean sock_get_address_info_async_cb (GIOChannel *source,
+ GIOCondition condition,
+ gpointer data);
+static SockLookupData *sock_get_address_info_async
+ (const gchar *hostname,
+ gushort port,
+ SockAddrFunc func,
+ gpointer data);
+static gint sock_get_address_info_async_cancel (SockLookupData *lookup_data);
+#endif /* G_OS_UNIX */
+
+
+gint sock_init(void)
+{
+#ifdef G_OS_WIN32
+ WSADATA wsadata;
+ gint result;
+
+ result = WSAStartup(MAKEWORD(2, 2), &wsadata);
+ if (result != NO_ERROR) {
+ g_warning("WSAStartup() failed\n");
+ return -1;
+ }
+#endif
+ return 0;
+}
+
+gint sock_cleanup(void)
+{
+#ifdef G_OS_WIN32
+ WSACleanup();
+#endif
+ return 0;
+}
+
+gint sock_set_io_timeout(guint sec)
+{
+ io_timeout = sec;
+ return 0;
+}
+
+gint fd_connect_unix(const gchar *path)
+{
+#ifdef G_OS_UNIX
+ gint sock;
+ struct sockaddr_un addr;
+
+ sock = socket(PF_UNIX, SOCK_STREAM, 0);
+ if (sock < 0) {
+ perror("sock_connect_unix(): socket");
+ return -1;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
+
+ if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ fd_close(sock);
+ return -1;
+ }
+
+ return sock;
+#else
+ return -1;
+#endif
+}
+
+gint fd_open_unix(const gchar *path)
+{
+#ifdef G_OS_UNIX
+ gint sock;
+ struct sockaddr_un addr;
+
+ sock = socket(PF_UNIX, SOCK_STREAM, 0);
+
+ if (sock < 0) {
+ perror("sock_open_unix(): socket");
+ return -1;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
+
+ if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ perror("bind");
+ fd_close(sock);
+ return -1;
+ }
+
+ if (listen(sock, 1) < 0) {
+ perror("listen");
+ fd_close(sock);
+ return -1;
+ }
+
+ return sock;
+#else
+ return -1;
+#endif
+}
+
+gint fd_accept(gint sock)
+{
+#ifdef G_OS_UNIX
+ struct sockaddr_in caddr;
+ guint caddr_len;
+
+ caddr_len = sizeof(caddr);
+ return accept(sock, (struct sockaddr *)&caddr, &caddr_len);
+#else
+ return -1;
+#endif
+}
+
+
+static gint set_nonblocking_mode(gint fd, gboolean nonblock)
+{
+#ifdef G_OS_UNIX
+ gint flags;
+
+ flags = fcntl(fd, F_GETFL, 0);
+ if (flags < 0) {
+ perror("fcntl");
+ return -1;
+ }
+
+ if (nonblock)
+ flags |= O_NONBLOCK;
+ else
+ flags &= ~O_NONBLOCK;
+
+ return fcntl(fd, F_SETFL, flags);
+#else
+ return -1;
+#endif
+}
+
+gint sock_set_nonblocking_mode(SockInfo *sock, gboolean nonblock)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+
+ return set_nonblocking_mode(sock->sock, nonblock);
+}
+
+static gboolean is_nonblocking_mode(gint fd)
+{
+#ifdef G_OS_UNIX
+ gint flags;
+
+ flags = fcntl(fd, F_GETFL, 0);
+ if (flags < 0) {
+ perror("fcntl");
+ return FALSE;
+ }
+
+ return ((flags & O_NONBLOCK) != 0);
+#else
+ return FALSE;
+#endif
+}
+
+gboolean sock_is_nonblocking_mode(SockInfo *sock)
+{
+ g_return_val_if_fail(sock != NULL, FALSE);
+
+ return is_nonblocking_mode(sock->sock);
+}
+
+
+static gboolean sock_prepare(GSource *source, gint *timeout)
+{
+ *timeout = 1;
+ return FALSE;
+}
+
+static gboolean sock_check(GSource *source)
+{
+ SockInfo *sock = ((SockSource *)source)->sock;
+ struct timeval timeout = {0, 0};
+ fd_set fds;
+ GIOCondition condition = sock->condition;
+
+#if USE_SSL
+ if (sock->ssl) {
+ if (condition & G_IO_IN) {
+ if (SSL_pending(sock->ssl) > 0)
+ return TRUE;
+ if (SSL_want_write(sock->ssl))
+ condition |= G_IO_OUT;
+ }
+
+ if (condition & G_IO_OUT) {
+ if (SSL_want_read(sock->ssl))
+ condition |= G_IO_IN;
+ }
+ }
+#endif
+
+ FD_ZERO(&fds);
+ FD_SET(sock->sock, &fds);
+
+ select(sock->sock + 1,
+ (condition & G_IO_IN) ? &fds : NULL,
+ (condition & G_IO_OUT) ? &fds : NULL,
+ NULL, &timeout);
+
+ return FD_ISSET(sock->sock, &fds) != 0;
+}
+
+static gboolean sock_dispatch(GSource *source, GSourceFunc callback,
+ gpointer user_data)
+{
+ SockInfo *sock = ((SockSource *)source)->sock;
+
+ return sock->callback(sock, sock->condition, sock->data);
+}
+
+static gboolean sock_watch_cb(GIOChannel *source, GIOCondition condition,
+ gpointer data)
+{
+ SockInfo *sock = (SockInfo *)data;
+
+ if ((condition & sock->condition) == 0)
+ return TRUE;
+
+ return sock->callback(sock, sock->condition, sock->data);
+}
+
+guint sock_add_watch(SockInfo *sock, GIOCondition condition, SockFunc func,
+ gpointer data)
+{
+ sock->callback = func;
+ sock->condition = condition;
+ sock->data = data;
+
+#if USE_SSL
+ if (sock->ssl) {
+ GSource *source;
+
+ source = g_source_new(&sock_watch_funcs, sizeof(SockSource));
+ ((SockSource *)source)->sock = sock;
+ g_source_set_priority(source, G_PRIORITY_DEFAULT);
+ g_source_set_can_recurse(source, FALSE);
+ return g_source_attach(source, NULL);
+ }
+#endif
+
+ return g_io_add_watch(sock->sock_ch, condition, sock_watch_cb, sock);
+}
+
+static gint fd_check_io(gint fd, GIOCondition cond)
+{
+ struct timeval timeout;
+ fd_set fds;
+
+ if (is_nonblocking_mode(fd))
+ return 0;
+
+ timeout.tv_sec = io_timeout;
+ timeout.tv_usec = 0;
+
+ FD_ZERO(&fds);
+ FD_SET(fd, &fds);
+
+ if (cond == G_IO_IN) {
+ select(fd + 1, &fds, NULL, NULL,
+ io_timeout > 0 ? &timeout : NULL);
+ } else {
+ select(fd + 1, NULL, &fds, NULL,
+ io_timeout > 0 ? &timeout : NULL);
+ }
+
+ if (FD_ISSET(fd, &fds)) {
+ return 0;
+ } else {
+ g_warning("Socket IO timeout\n");
+ return -1;
+ }
+}
+
+#ifdef G_OS_UNIX
+static sigjmp_buf jmpenv;
+
+static void timeout_handler(gint sig)
+{
+ siglongjmp(jmpenv, 1);
+}
+#endif
+
+static gint sock_connect_with_timeout(gint sock,
+ const struct sockaddr *serv_addr,
+ gint addrlen,
+ guint timeout_secs)
+{
+ gint ret;
+#ifdef G_OS_UNIX
+ void (*prev_handler)(gint);
+
+ alarm(0);
+ prev_handler = signal(SIGALRM, timeout_handler);
+ if (sigsetjmp(jmpenv, 1)) {
+ alarm(0);
+ signal(SIGALRM, prev_handler);
+ errno = ETIMEDOUT;
+ return -1;
+ }
+ alarm(timeout_secs);
+#endif
+
+ ret = connect(sock, serv_addr, addrlen);
+
+#ifdef G_OS_UNIX
+ alarm(0);
+ signal(SIGALRM, prev_handler);
+#endif
+
+ return ret;
+}
+
+struct hostent *my_gethostbyname(const gchar *hostname)
+{
+ struct hostent *hp;
+#ifdef G_OS_UNIX
+ void (*prev_handler)(gint);
+
+ alarm(0);
+ prev_handler = signal(SIGALRM, timeout_handler);
+ if (sigsetjmp(jmpenv, 1)) {
+ alarm(0);
+ signal(SIGALRM, prev_handler);
+ fprintf(stderr, "%s: host lookup timed out.\n", hostname);
+ errno = 0;
+ return NULL;
+ }
+ alarm(io_timeout);
+#endif
+
+ if ((hp = gethostbyname(hostname)) == NULL) {
+#ifdef G_OS_UNIX
+ alarm(0);
+ signal(SIGALRM, prev_handler);
+#endif
+ fprintf(stderr, "%s: unknown host.\n", hostname);
+ errno = 0;
+ return NULL;
+ }
+
+#ifdef G_OS_UNIX
+ alarm(0);
+ signal(SIGALRM, prev_handler);
+#endif
+
+ return hp;
+}
+
+#ifndef INET6
+static gint my_inet_aton(const gchar *hostname, struct in_addr *inp)
+{
+#if HAVE_INET_ATON
+ return inet_aton(hostname, inp);
+#else
+#if HAVE_INET_ADDR
+ guint32 inaddr;
+
+ inaddr = inet_addr(hostname);
+ if (inaddr != -1) {
+ memcpy(inp, &inaddr, sizeof(inaddr));
+ return 1;
+ } else
+ return 0;
+#else
+ return 0;
+#endif
+#endif /* HAVE_INET_ATON */
+}
+
+static gint sock_connect_by_hostname(gint sock, const gchar *hostname,
+ gushort port)
+{
+ struct hostent *hp;
+ struct sockaddr_in ad;
+
+ memset(&ad, 0, sizeof(ad));
+ ad.sin_family = AF_INET;
+ ad.sin_port = htons(port);
+
+ if (!my_inet_aton(hostname, &ad.sin_addr)) {
+ if ((hp = my_gethostbyname(hostname)) == NULL) {
+ fprintf(stderr, "%s: unknown host.\n", hostname);
+ errno = 0;
+ return -1;
+ }
+
+ if (hp->h_length != 4 && hp->h_length != 8) {
+ fprintf(stderr, "illegal address length received for host %s\n", hostname);
+ errno = 0;
+ return -1;
+ }
+
+ memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);
+ }
+
+ return sock_connect_with_timeout(sock, (struct sockaddr *)&ad,
+ sizeof(ad), io_timeout);
+}
+
+#else /* INET6 */
+static gint sock_connect_by_getaddrinfo(const gchar *hostname, gushort port)
+{
+ gint sock = -1, gai_error;
+ struct addrinfo hints, *res, *ai;
+ gchar port_str[6];
+
+ memset(&hints, 0, sizeof(hints));
+ /* hints.ai_flags = AI_CANONNAME; */
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+
+ /* convert port from integer to string. */
+ g_snprintf(port_str, sizeof(port_str), "%d", port);
+
+ if ((gai_error = getaddrinfo(hostname, port_str, &hints, &res)) != 0) {
+ fprintf(stderr, "getaddrinfo for %s:%s failed: %s\n",
+ hostname, port_str, gai_strerror(gai_error));
+ return -1;
+ }
+
+ for (ai = res; ai != NULL; ai = ai->ai_next) {
+ sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+ if (sock < 0)
+ continue;
+
+ if (sock_connect_with_timeout
+ (sock, ai->ai_addr, ai->ai_addrlen, io_timeout) == 0)
+ break;
+
+ fd_close(sock);
+ }
+
+ if (res != NULL)
+ freeaddrinfo(res);
+
+ if (ai == NULL)
+ return -1;
+
+ return sock;
+}
+#endif /* !INET6 */
+
+SockInfo *sock_connect(const gchar *hostname, gushort port)
+{
+#ifdef G_OS_WIN32
+ SOCKET sock;
+#else
+ gint sock;
+#endif
+ SockInfo *sockinfo;
+
+#ifdef INET6
+ if ((sock = sock_connect_by_getaddrinfo(hostname, port)) < 0)
+ return NULL;
+#else
+#ifdef G_OS_WIN32
+ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
+ g_warning("socket() failed: %ld\n", WSAGetLastError());
+#else
+ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+ perror("socket");
+#endif /* G_OS_WIN32 */
+ return NULL;
+ }
+
+ if (sock_connect_by_hostname(sock, hostname, port) < 0) {
+ if (errno != 0) perror("connect");
+ fd_close(sock);
+ return NULL;
+ }
+#endif /* INET6 */
+
+ sockinfo = g_new0(SockInfo, 1);
+ sockinfo->sock = sock;
+ sockinfo->sock_ch = g_io_channel_unix_new(sock);
+ sockinfo->hostname = g_strdup(hostname);
+ sockinfo->port = port;
+ sockinfo->state = CONN_ESTABLISHED;
+
+ g_usleep(100000);
+
+ return sockinfo;
+}
+
+#ifdef G_OS_UNIX
+static void sock_address_list_free(GList *addr_list)
+{
+ GList *cur;
+
+ for (cur = addr_list; cur != NULL; cur = cur->next) {
+ SockAddrData *addr_data = (SockAddrData *)cur->data;
+ g_free(addr_data->addr);
+ g_free(addr_data);
+ }
+
+ g_list_free(addr_list);
+}
+
+/* asynchronous TCP connection */
+
+static gboolean sock_connect_async_cb(GIOChannel *source,
+ GIOCondition condition, gpointer data)
+{
+ SockConnectData *conn_data = (SockConnectData *)data;
+ gint fd;
+ gint val;
+ guint len;
+ SockInfo *sockinfo;
+
+ fd = g_io_channel_unix_get_fd(source);
+
+ conn_data->io_tag = 0;
+ conn_data->channel = NULL;
+ g_io_channel_unref(source);
+
+ len = sizeof(val);
+ if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) < 0) {
+ perror("getsockopt");
+ fd_close(fd);
+ sock_connect_address_list_async(conn_data);
+ return FALSE;
+ }
+
+ if (val != 0) {
+ fd_close(fd);
+ sock_connect_address_list_async(conn_data);
+ return FALSE;
+ }
+
+ sockinfo = g_new0(SockInfo, 1);
+ sockinfo->sock = fd;
+ sockinfo->sock_ch = g_io_channel_unix_new(fd);
+ sockinfo->hostname = g_strdup(conn_data->hostname);
+ sockinfo->port = conn_data->port;
+ sockinfo->state = CONN_ESTABLISHED;
+
+ conn_data->func(sockinfo, conn_data->data);
+
+ sock_connect_async_cancel(conn_data->id);
+
+ return FALSE;
+}
+
+static gint sock_connect_async_get_address_info_cb(GList *addr_list,
+ gpointer data)
+{
+ SockConnectData *conn_data = (SockConnectData *)data;
+
+ conn_data->addr_list = addr_list;
+ conn_data->cur_addr = addr_list;
+ conn_data->lookup_data = NULL;
+
+ return sock_connect_address_list_async(conn_data);
+}
+
+gint sock_connect_async(const gchar *hostname, gushort port,
+ SockConnectFunc func, gpointer data)
+{
+ static gint id = 1;
+ SockConnectData *conn_data;
+
+ conn_data = g_new0(SockConnectData, 1);
+ conn_data->id = id++;
+ conn_data->hostname = g_strdup(hostname);
+ conn_data->port = port;
+ conn_data->addr_list = NULL;
+ conn_data->cur_addr = NULL;
+ conn_data->io_tag = 0;
+ conn_data->func = func;
+ conn_data->data = data;
+
+ conn_data->lookup_data = sock_get_address_info_async
+ (hostname, port, sock_connect_async_get_address_info_cb,
+ conn_data);
+
+ if (conn_data->lookup_data == NULL) {
+ g_free(conn_data->hostname);
+ g_free(conn_data);
+ return -1;
+ }
+
+ sock_connect_data_list = g_list_append(sock_connect_data_list,
+ conn_data);
+
+ return conn_data->id;
+}
+
+gint sock_connect_async_cancel(gint id)
+{
+ SockConnectData *conn_data = NULL;
+ GList *cur;
+
+ for (cur = sock_connect_data_list; cur != NULL; cur = cur->next) {
+ if (((SockConnectData *)cur->data)->id == id) {
+ conn_data = (SockConnectData *)cur->data;
+ break;
+ }
+ }
+
+ if (conn_data) {
+ sock_connect_data_list = g_list_remove(sock_connect_data_list,
+ conn_data);
+
+ if (conn_data->lookup_data)
+ sock_get_address_info_async_cancel
+ (conn_data->lookup_data);
+
+ if (conn_data->io_tag > 0)
+ g_source_remove(conn_data->io_tag);
+ if (conn_data->channel) {
+ g_io_channel_shutdown(conn_data->channel, FALSE, NULL);
+ g_io_channel_unref(conn_data->channel);
+ }
+
+ sock_address_list_free(conn_data->addr_list);
+ g_free(conn_data->hostname);
+ g_free(conn_data);
+ } else {
+ g_warning("sock_connect_async_cancel: id %d not found.\n", id);
+ return -1;
+ }
+
+ return 0;
+}
+
+static gint sock_connect_address_list_async(SockConnectData *conn_data)
+{
+ SockAddrData *addr_data;
+ gint sock = -1;
+
+ for (; conn_data->cur_addr != NULL;
+ conn_data->cur_addr = conn_data->cur_addr->next) {
+ addr_data = (SockAddrData *)conn_data->cur_addr->data;
+
+ if ((sock = socket(addr_data->family, addr_data->socktype,
+ addr_data->protocol)) < 0) {
+ perror("socket");
+ continue;
+ }
+
+ set_nonblocking_mode(sock, TRUE);
+
+ if (connect(sock, addr_data->addr, addr_data->addr_len) < 0) {
+ if (EINPROGRESS == errno) {
+ break;
+ } else {
+ perror("connect");
+ fd_close(sock);
+ }
+ } else
+ break;
+ }
+
+ if (conn_data->cur_addr == NULL) {
+ g_warning("sock_connect_address_list_async: "
+ "connection to %s:%d failed\n",
+ conn_data->hostname, conn_data->port);
+ conn_data->func(NULL, conn_data->data);
+ sock_connect_async_cancel(conn_data->id);
+ return -1;
+ }
+
+ conn_data->cur_addr = conn_data->cur_addr->next;
+
+ conn_data->channel = g_io_channel_unix_new(sock);
+ conn_data->io_tag = g_io_add_watch(conn_data->channel, G_IO_OUT,
+ sock_connect_async_cb, conn_data);
+
+ return 0;
+}
+
+/* asynchronous DNS lookup */
+
+static gboolean sock_get_address_info_async_cb(GIOChannel *source,
+ GIOCondition condition,
+ gpointer data)
+{
+ SockLookupData *lookup_data = (SockLookupData *)data;
+ GList *addr_list = NULL;
+ SockAddrData *addr_data;
+ gsize bytes_read;
+ gint ai_member[4];
+ struct sockaddr *addr;
+
+ for (;;) {
+ if (g_io_channel_read(source, (gchar *)ai_member,
+ sizeof(ai_member), &bytes_read)
+ != G_IO_ERROR_NONE) {
+ g_warning("sock_get_address_info_async_cb: "
+ "address length read error\n");
+ break;
+ }
+
+ if (bytes_read == 0 || bytes_read != sizeof(ai_member))
+ break;
+
+ if (ai_member[0] == AF_UNSPEC) {
+ g_warning("DNS lookup failed\n");
+ break;
+ }
+
+ addr = g_malloc(ai_member[3]);
+ if (g_io_channel_read(source, (gchar *)addr, ai_member[3],
+ &bytes_read)
+ != G_IO_ERROR_NONE) {
+ g_warning("sock_get_address_info_async_cb: "
+ "address data read error\n");
+ g_free(addr);
+ break;
+ }
+
+ if (bytes_read != ai_member[3]) {
+ g_warning("sock_get_address_info_async_cb: "
+ "incomplete address data\n");
+ g_free(addr);
+ break;
+ }
+
+ addr_data = g_new0(SockAddrData, 1);
+ addr_data->family = ai_member[0];
+ addr_data->socktype = ai_member[1];
+ addr_data->protocol = ai_member[2];
+ addr_data->addr_len = ai_member[3];
+ addr_data->addr = addr;
+
+ addr_list = g_list_append(addr_list, addr_data);
+ }
+
+ g_io_channel_shutdown(source, FALSE, NULL);
+ g_io_channel_unref(source);
+
+ kill(lookup_data->child_pid, SIGKILL);
+ waitpid(lookup_data->child_pid, NULL, 0);
+
+ lookup_data->func(addr_list, lookup_data->data);
+
+ g_free(lookup_data->hostname);
+ g_free(lookup_data);
+
+ return FALSE;
+}
+
+static SockLookupData *sock_get_address_info_async(const gchar *hostname,
+ gushort port,
+ SockAddrFunc func,
+ gpointer data)
+{
+ SockLookupData *lookup_data = NULL;
+ gint pipe_fds[2];
+ pid_t pid;
+
+ if (pipe(pipe_fds) < 0) {
+ perror("pipe");
+ func(NULL, data);
+ return NULL;
+ }
+
+ if ((pid = fork()) < 0) {
+ perror("fork");
+ func(NULL, data);
+ return NULL;
+ }
+
+ /* child process */
+ if (pid == 0) {
+#ifdef INET6
+ gint gai_err;
+ struct addrinfo hints, *res, *ai;
+ gchar port_str[6];
+#else /* !INET6 */
+ struct hostent *hp;
+ gchar **addr_list_p;
+ struct sockaddr_in ad;
+#endif /* INET6 */
+ gint ai_member[4] = {AF_UNSPEC, 0, 0, 0};
+
+ close(pipe_fds[0]);
+
+#ifdef INET6
+ memset(&hints, 0, sizeof(hints));
+ /* hints.ai_flags = AI_CANONNAME; */
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+
+ g_snprintf(port_str, sizeof(port_str), "%d", port);
+
+ gai_err = getaddrinfo(hostname, port_str, &hints, &res);
+ if (gai_err != 0) {
+ g_warning("getaddrinfo for %s:%s failed: %s\n",
+ hostname, port_str, gai_strerror(gai_err));
+ fd_write_all(pipe_fds[1], (gchar *)ai_member,
+ sizeof(ai_member));
+ close(pipe_fds[1]);
+ _exit(1);
+ }
+
+ for (ai = res; ai != NULL; ai = ai->ai_next) {
+ ai_member[0] = ai->ai_family;
+ ai_member[1] = ai->ai_socktype;
+ ai_member[2] = ai->ai_protocol;
+ ai_member[3] = ai->ai_addrlen;
+
+ fd_write_all(pipe_fds[1], (gchar *)ai_member,
+ sizeof(ai_member));
+ fd_write_all(pipe_fds[1], (gchar *)ai->ai_addr,
+ ai->ai_addrlen);
+ }
+
+ if (res != NULL)
+ freeaddrinfo(res);
+#else /* !INET6 */
+ hp = my_gethostbyname(hostname);
+ if (hp == NULL || hp->h_addrtype != AF_INET) {
+ fd_write_all(pipe_fds[1], (gchar *)ai_member,
+ sizeof(ai_member));
+ close(pipe_fds[1]);
+ _exit(1);
+ }
+
+ ai_member[0] = AF_INET;
+ ai_member[1] = SOCK_STREAM;
+ ai_member[2] = IPPROTO_TCP;
+ ai_member[3] = sizeof(ad);
+
+ memset(&ad, 0, sizeof(ad));
+ ad.sin_family = AF_INET;
+ ad.sin_port = htons(port);
+
+ for (addr_list_p = hp->h_addr_list; *addr_list_p != NULL;
+ addr_list_p++) {
+ memcpy(&ad.sin_addr, *addr_list_p, hp->h_length);
+ fd_write_all(pipe_fds[1], (gchar *)ai_member,
+ sizeof(ai_member));
+ fd_write_all(pipe_fds[1], (gchar *)&ad, sizeof(ad));
+ }
+#endif /* INET6 */
+
+ close(pipe_fds[1]);
+
+ _exit(0);
+ } else {
+ close(pipe_fds[1]);
+
+ lookup_data = g_new0(SockLookupData, 1);
+ lookup_data->hostname = g_strdup(hostname);
+ lookup_data->child_pid = pid;
+ lookup_data->func = func;
+ lookup_data->data = data;
+
+ lookup_data->channel = g_io_channel_unix_new(pipe_fds[0]);
+ lookup_data->io_tag = g_io_add_watch
+ (lookup_data->channel, G_IO_IN,
+ sock_get_address_info_async_cb, lookup_data);
+ }
+
+ return lookup_data;
+}
+
+static gint sock_get_address_info_async_cancel(SockLookupData *lookup_data)
+{
+ if (lookup_data->io_tag > 0)
+ g_source_remove(lookup_data->io_tag);
+ if (lookup_data->channel) {
+ g_io_channel_shutdown(lookup_data->channel, FALSE, NULL);
+ g_io_channel_unref(lookup_data->channel);
+ }
+
+ if (lookup_data->child_pid > 0) {
+ kill(lookup_data->child_pid, SIGKILL);
+ waitpid(lookup_data->child_pid, NULL, 0);
+ }
+
+ g_free(lookup_data->hostname);
+ g_free(lookup_data);
+
+ return 0;
+}
+#endif /* G_OS_UNIX */
+
+
+gint sock_printf(SockInfo *sock, const gchar *format, ...)
+{
+ va_list args;
+ gchar buf[BUFFSIZE];
+
+ va_start(args, format);
+ g_vsnprintf(buf, sizeof(buf), format, args);
+ va_end(args);
+
+ return sock_write_all(sock, buf, strlen(buf));
+}
+
+gint sock_read(SockInfo *sock, gchar *buf, gint len)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+
+#if USE_SSL
+ if (sock->ssl)
+ return ssl_read(sock->ssl, buf, len);
+#endif
+ return fd_read(sock->sock, buf, len);
+}
+
+gint fd_read(gint fd, gchar *buf, gint len)
+{
+ if (fd_check_io(fd, G_IO_IN) < 0)
+ return -1;
+
+#ifdef G_OS_WIN32
+ return recv(fd, buf, len, 0);
+#else
+ return read(fd, buf, len);
+#endif
+}
+
+#if USE_SSL
+gint ssl_read(SSL *ssl, gchar *buf, gint len)
+{
+ gint err, ret;
+
+ if (SSL_pending(ssl) == 0) {
+ if (fd_check_io(SSL_get_rfd(ssl), G_IO_IN) < 0)
+ return -1;
+ }
+
+ ret = SSL_read(ssl, buf, len);
+
+ switch ((err = SSL_get_error(ssl, ret))) {
+ case SSL_ERROR_NONE:
+ return ret;
+ case SSL_ERROR_WANT_READ:
+ case SSL_ERROR_WANT_WRITE:
+ errno = EAGAIN;
+ return -1;
+ case SSL_ERROR_ZERO_RETURN:
+ return 0;
+ default:
+ g_warning("SSL_read() returned error %d, ret = %d\n", err, ret);
+ if (ret == 0)
+ return 0;
+ return -1;
+ }
+}
+#endif
+
+gint sock_write(SockInfo *sock, const gchar *buf, gint len)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+
+#if USE_SSL
+ if (sock->ssl)
+ return ssl_write(sock->ssl, buf, len);
+#endif
+ return fd_write(sock->sock, buf, len);
+}
+
+gint fd_write(gint fd, const gchar *buf, gint len)
+{
+ if (fd_check_io(fd, G_IO_OUT) < 0)
+ return -1;
+
+#ifdef G_OS_WIN32
+ return send(fd, buf, len, 0);
+#else
+ return write(fd, buf, len);
+#endif
+}
+
+#if USE_SSL
+gint ssl_write(SSL *ssl, const gchar *buf, gint len)
+{
+ gint ret;
+
+ ret = SSL_write(ssl, buf, len);
+
+ switch (SSL_get_error(ssl, ret)) {
+ case SSL_ERROR_NONE:
+ return ret;
+ case SSL_ERROR_WANT_READ:
+ case SSL_ERROR_WANT_WRITE:
+ errno = EAGAIN;
+ return -1;
+ default:
+ return -1;
+ }
+}
+#endif
+
+gint sock_write_all(SockInfo *sock, const gchar *buf, gint len)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+
+#if USE_SSL
+ if (sock->ssl)
+ return ssl_write_all(sock->ssl, buf, len);
+#endif
+ return fd_write_all(sock->sock, buf, len);
+}
+
+gint fd_write_all(gint fd, const gchar *buf, gint len)
+{
+ gint n, wrlen = 0;
+
+ while (len) {
+ n = fd_write(fd, buf, len);
+ if (n <= 0)
+ return -1;
+ len -= n;
+ wrlen += n;
+ buf += n;
+ }
+
+ return wrlen;
+}
+
+#if USE_SSL
+gint ssl_write_all(SSL *ssl, const gchar *buf, gint len)
+{
+ gint n, wrlen = 0;
+
+ while (len) {
+ n = ssl_write(ssl, buf, len);
+ if (n <= 0)
+ return -1;
+ len -= n;
+ wrlen += n;
+ buf += n;
+ }
+
+ return wrlen;
+}
+#endif
+
+gint fd_recv(gint fd, gchar *buf, gint len, gint flags)
+{
+ if (fd_check_io(fd, G_IO_IN) < 0)
+ return -1;
+
+ return recv(fd, buf, len, flags);
+}
+
+gint fd_gets(gint fd, gchar *buf, gint len)
+{
+ gchar *newline, *bp = buf;
+ gint n;
+
+ if (--len < 1)
+ return -1;
+ do {
+ if ((n = fd_recv(fd, bp, len, MSG_PEEK)) <= 0)
+ return -1;
+ if ((newline = memchr(bp, '\n', n)) != NULL)
+ n = newline - bp + 1;
+ if ((n = fd_read(fd, bp, n)) < 0)
+ return -1;
+ bp += n;
+ len -= n;
+ } while (!newline && len);
+
+ *bp = '\0';
+ return bp - buf;
+}
+
+#if USE_SSL
+gint ssl_gets(SSL *ssl, gchar *buf, gint len)
+{
+ gchar *newline, *bp = buf;
+ gint n;
+
+ if (--len < 1)
+ return -1;
+ do {
+ if ((n = ssl_peek(ssl, bp, len)) <= 0)
+ return -1;
+ if ((newline = memchr(bp, '\n', n)) != NULL)
+ n = newline - bp + 1;
+ if ((n = ssl_read(ssl, bp, n)) < 0)
+ return -1;
+ bp += n;
+ len -= n;
+ } while (!newline && len);
+
+ *bp = '\0';
+ return bp - buf;
+}
+#endif
+
+gint sock_gets(SockInfo *sock, gchar *buf, gint len)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+
+#if USE_SSL
+ if (sock->ssl)
+ return ssl_gets(sock->ssl, buf, len);
+#endif
+ return fd_gets(sock->sock, buf, len);
+}
+
+gint fd_getline(gint fd, gchar **line)
+{
+ gchar buf[BUFFSIZE];
+ gchar *str = NULL;
+ gint len;
+ gulong size = 0;
+ gulong cur_offset = 0;
+
+ while ((len = fd_gets(fd, buf, sizeof(buf))) > 0) {
+ size += len;
+ str = g_realloc(str, size + 1);
+ memcpy(str + cur_offset, buf, len + 1);
+ cur_offset += len;
+ if (buf[len - 1] == '\n')
+ break;
+ }
+
+ *line = str;
+
+ if (!str)
+ return -1;
+ else
+ return (gint)size;
+}
+
+#if USE_SSL
+gint ssl_getline(SSL *ssl, gchar **line)
+{
+ gchar buf[BUFFSIZE];
+ gchar *str = NULL;
+ gint len;
+ gulong size = 0;
+ gulong cur_offset = 0;
+
+ while ((len = ssl_gets(ssl, buf, sizeof(buf))) > 0) {
+ size += len;
+ str = g_realloc(str, size + 1);
+ memcpy(str + cur_offset, buf, len + 1);
+ cur_offset += len;
+ if (buf[len - 1] == '\n')
+ break;
+ }
+
+ *line = str;
+
+ if (!str)
+ return -1;
+ else
+ return (gint)size;
+}
+#endif
+
+gint sock_getline(SockInfo *sock, gchar **line)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+ g_return_val_if_fail(line != NULL, -1);
+
+#if USE_SSL
+ if (sock->ssl)
+ return ssl_getline(sock->ssl, line);
+#endif
+ return fd_getline(sock->sock, line);
+}
+
+gint sock_puts(SockInfo *sock, const gchar *buf)
+{
+ gint ret;
+
+ if ((ret = sock_write_all(sock, buf, strlen(buf))) < 0)
+ return ret;
+ return sock_write_all(sock, "\r\n", 2);
+}
+
+/* peek at the socket data without actually reading it */
+#if USE_SSL
+gint ssl_peek(SSL *ssl, gchar *buf, gint len)
+{
+ gint err, ret;
+
+ if (SSL_pending(ssl) == 0) {
+ if (fd_check_io(SSL_get_rfd(ssl), G_IO_IN) < 0)
+ return -1;
+ }
+
+ ret = SSL_peek(ssl, buf, len);
+
+ switch ((err = SSL_get_error(ssl, ret))) {
+ case SSL_ERROR_NONE:
+ return ret;
+ case SSL_ERROR_WANT_READ:
+ case SSL_ERROR_WANT_WRITE:
+ errno = EAGAIN;
+ return -1;
+ case SSL_ERROR_ZERO_RETURN:
+ return 0;
+ default:
+ g_warning("SSL_peek() returned error %d, ret = %d\n", err, ret);
+ if (ret == 0)
+ return 0;
+ return -1;
+ }
+}
+#endif
+
+gint sock_peek(SockInfo *sock, gchar *buf, gint len)
+{
+ g_return_val_if_fail(sock != NULL, -1);
+
+#if USE_SSL
+ if (sock->ssl)
+ return ssl_peek(sock->ssl, buf, len);
+#endif
+ return fd_recv(sock->sock, buf, len, MSG_PEEK);
+}
+
+gint sock_close(SockInfo *sock)
+{
+ if (!sock)
+ return 0;
+
+#if USE_SSL
+ if (sock->ssl)
+ ssl_done_socket(sock);
+#endif
+
+ if (sock->sock_ch) {
+ g_io_channel_shutdown(sock->sock_ch, FALSE, NULL);
+ g_io_channel_unref(sock->sock_ch);
+ }
+
+ g_free(sock->hostname);
+ g_free(sock);
+
+ return 0;
+}
+
+gint fd_close(gint fd)
+{
+#ifdef G_OS_WIN32
+ return closesocket(fd);
+#else
+ return close(fd);
+#endif
+}
diff --git a/libsylph/socket.h b/libsylph/socket.h
new file mode 100644
index 00000000..5721a304
--- /dev/null
+++ b/libsylph/socket.h
@@ -0,0 +1,124 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __SOCKET_H__
+#define __SOCKET_H__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+#if HAVE_NETDB_H
+# include <netdb.h>
+#endif
+
+typedef struct _SockInfo SockInfo;
+
+#if USE_SSL
+# include "ssl.h"
+#endif
+
+typedef enum
+{
+ CONN_READY,
+ CONN_LOOKUPSUCCESS,
+ CONN_ESTABLISHED,
+ CONN_LOOKUPFAILED,
+ CONN_FAILED
+} ConnectionState;
+
+typedef gint (*SockConnectFunc) (SockInfo *sock,
+ gpointer data);
+typedef gboolean (*SockFunc) (SockInfo *sock,
+ GIOCondition condition,
+ gpointer data);
+
+struct _SockInfo
+{
+ gint sock;
+#if USE_SSL
+ SSL *ssl;
+#endif
+ GIOChannel *sock_ch;
+
+ gchar *hostname;
+ gushort port;
+ ConnectionState state;
+ gpointer data;
+
+ SockFunc callback;
+ GIOCondition condition;
+};
+
+gint sock_init (void);
+gint sock_cleanup (void);
+
+gint sock_set_io_timeout (guint sec);
+
+gint sock_set_nonblocking_mode (SockInfo *sock, gboolean nonblock);
+gboolean sock_is_nonblocking_mode (SockInfo *sock);
+
+guint sock_add_watch (SockInfo *sock, GIOCondition condition,
+ SockFunc func, gpointer data);
+
+struct hostent *my_gethostbyname (const gchar *hostname);
+
+SockInfo *sock_connect (const gchar *hostname, gushort port);
+#ifdef G_OS_UNIX
+gint sock_connect_async (const gchar *hostname, gushort port,
+ SockConnectFunc func, gpointer data);
+gint sock_connect_async_cancel (gint id);
+#endif
+
+/* Basic I/O functions */
+gint sock_printf (SockInfo *sock, const gchar *format, ...)
+ G_GNUC_PRINTF(2, 3);
+gint sock_read (SockInfo *sock, gchar *buf, gint len);
+gint sock_write (SockInfo *sock, const gchar *buf, gint len);
+gint sock_write_all (SockInfo *sock, const gchar *buf, gint len);
+gint sock_gets (SockInfo *sock, gchar *buf, gint len);
+gint sock_getline (SockInfo *sock, gchar **line);
+gint sock_puts (SockInfo *sock, const gchar *buf);
+gint sock_peek (SockInfo *sock, gchar *buf, gint len);
+gint sock_close (SockInfo *sock);
+
+/* Functions to directly work on FD. They are needed for pipes */
+gint fd_connect_unix (const gchar *path);
+gint fd_open_unix (const gchar *path);
+gint fd_accept (gint sock);
+
+gint fd_read (gint sock, gchar *buf, gint len);
+gint fd_write (gint sock, const gchar *buf, gint len);
+gint fd_write_all (gint sock, const gchar *buf, gint len);
+gint fd_gets (gint sock, gchar *buf, gint len);
+gint fd_getline (gint sock, gchar **line);
+gint fd_close (gint sock);
+
+/* Functions for SSL */
+#if USE_SSL
+gint ssl_read (SSL *ssl, gchar *buf, gint len);
+gint ssl_write (SSL *ssl, const gchar *buf, gint len);
+gint ssl_write_all (SSL *ssl, const gchar *buf, gint len);
+gint ssl_gets (SSL *ssl, gchar *buf, gint len);
+gint ssl_getline (SSL *ssl, gchar **line);
+gint ssl_peek (SSL *ssl, gchar *buf, gint len);
+#endif
+
+#endif /* __SOCKET_H__ */
diff --git a/libsylph/ssl.c b/libsylph/ssl.c
new file mode 100644
index 00000000..b57c60a9
--- /dev/null
+++ b/libsylph/ssl.c
@@ -0,0 +1,175 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#if USE_SSL
+
+#include "defs.h"
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include "utils.h"
+#include "ssl.h"
+
+static SSL_CTX *ssl_ctx_SSLv23;
+static SSL_CTX *ssl_ctx_TLSv1;
+
+void ssl_init(void)
+{
+ gchar *certs_dir;
+
+ SSL_library_init();
+ SSL_load_error_strings();
+
+ certs_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "certs", NULL);
+ if (!is_dir_exist(certs_dir)) {
+ debug_print("%s doesn't exist, or not a directory.\n",
+ certs_dir);
+ g_free(certs_dir);
+ certs_dir = NULL;
+ }
+
+ ssl_ctx_SSLv23 = SSL_CTX_new(SSLv23_client_method());
+ if (ssl_ctx_SSLv23 == NULL) {
+ debug_print(_("SSLv23 not available\n"));
+ } else {
+ debug_print(_("SSLv23 available\n"));
+ if (certs_dir &&
+ !SSL_CTX_load_verify_locations(ssl_ctx_SSLv23, NULL,
+ certs_dir))
+ g_warning("SSLv23 SSL_CTX_load_verify_locations failed.\n");
+ }
+
+ ssl_ctx_TLSv1 = SSL_CTX_new(TLSv1_client_method());
+ if (ssl_ctx_TLSv1 == NULL) {
+ debug_print(_("TLSv1 not available\n"));
+ } else {
+ debug_print(_("TLSv1 available\n"));
+ if (certs_dir &&
+ !SSL_CTX_load_verify_locations(ssl_ctx_TLSv1, NULL,
+ certs_dir))
+ g_warning("TLSv1 SSL_CTX_load_verify_locations failed.\n");
+ }
+
+ g_free(certs_dir);
+}
+
+void ssl_done(void)
+{
+ if (ssl_ctx_SSLv23) {
+ SSL_CTX_free(ssl_ctx_SSLv23);
+ }
+
+ if (ssl_ctx_TLSv1) {
+ SSL_CTX_free(ssl_ctx_TLSv1);
+ }
+}
+
+gboolean ssl_init_socket(SockInfo *sockinfo)
+{
+ return ssl_init_socket_with_method(sockinfo, SSL_METHOD_SSLv23);
+}
+
+gboolean ssl_init_socket_with_method(SockInfo *sockinfo, SSLMethod method)
+{
+ X509 *server_cert;
+ gint ret;
+
+ switch (method) {
+ case SSL_METHOD_SSLv23:
+ if (!ssl_ctx_SSLv23) {
+ g_warning(_("SSL method not available\n"));
+ return FALSE;
+ }
+ sockinfo->ssl = SSL_new(ssl_ctx_SSLv23);
+ break;
+ case SSL_METHOD_TLSv1:
+ if (!ssl_ctx_TLSv1) {
+ g_warning(_("SSL method not available\n"));
+ return FALSE;
+ }
+ sockinfo->ssl = SSL_new(ssl_ctx_TLSv1);
+ break;
+ default:
+ g_warning(_("Unknown SSL method *PROGRAM BUG*\n"));
+ return FALSE;
+ break;
+ }
+
+ if (sockinfo->ssl == NULL) {
+ g_warning(_("Error creating ssl context\n"));
+ return FALSE;
+ }
+
+ SSL_set_fd(sockinfo->ssl, sockinfo->sock);
+ if ((ret = SSL_connect(sockinfo->ssl)) == -1) {
+ g_warning(_("SSL connect failed (%s)\n"),
+ ERR_error_string(ERR_get_error(), NULL));
+ return FALSE;
+ }
+
+ /* Get the cipher */
+
+ debug_print(_("SSL connection using %s\n"),
+ SSL_get_cipher(sockinfo->ssl));
+
+ /* Get server's certificate (note: beware of dynamic allocation) */
+
+ if ((server_cert = SSL_get_peer_certificate(sockinfo->ssl)) != NULL) {
+ gchar *str;
+ glong verify_result;
+
+ debug_print(_("Server certificate:\n"));
+
+ if ((str = X509_NAME_oneline(X509_get_subject_name(server_cert), 0, 0)) != NULL) {
+ debug_print(_(" Subject: %s\n"), str);
+ g_free(str);
+ }
+
+ if ((str = X509_NAME_oneline(X509_get_issuer_name(server_cert), 0, 0)) != NULL) {
+ debug_print(_(" Issuer: %s\n"), str);
+ g_free(str);
+ }
+
+ verify_result = SSL_get_verify_result(sockinfo->ssl);
+ if (verify_result == X509_V_OK)
+ debug_print("SSL verify OK\n");
+ else
+ g_warning("%s: SSL certificate verify failed (%ld: %s)\n",
+ sockinfo->hostname, verify_result,
+ X509_verify_cert_error_string(verify_result));
+
+ X509_free(server_cert);
+ }
+
+ return TRUE;
+}
+
+void ssl_done_socket(SockInfo *sockinfo)
+{
+ if (sockinfo->ssl) {
+ SSL_free(sockinfo->ssl);
+ }
+}
+
+#endif /* USE_SSL */
diff --git a/libsylph/ssl.h b/libsylph/ssl.h
new file mode 100644
index 00000000..6c13ddac
--- /dev/null
+++ b/libsylph/ssl.h
@@ -0,0 +1,58 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2002 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __SSL_H__
+#define __SSL_H__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#if USE_SSL
+
+#include <glib.h>
+#include <openssl/crypto.h>
+#include <openssl/x509.h>
+#include <openssl/pem.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include "socket.h"
+
+typedef enum {
+ SSL_METHOD_SSLv23,
+ SSL_METHOD_TLSv1
+} SSLMethod;
+
+typedef enum {
+ SSL_NONE,
+ SSL_TUNNEL,
+ SSL_STARTTLS
+} SSLType;
+
+void ssl_init (void);
+void ssl_done (void);
+gboolean ssl_init_socket (SockInfo *sockinfo);
+gboolean ssl_init_socket_with_method (SockInfo *sockinfo,
+ SSLMethod method);
+void ssl_done_socket (SockInfo *sockinfo);
+
+#endif /* USE_SSL */
+
+#endif /* __SSL_H__ */
diff --git a/libsylph/stringtable.c b/libsylph/stringtable.c
new file mode 100644
index 00000000..da5e0ea4
--- /dev/null
+++ b/libsylph/stringtable.c
@@ -0,0 +1,163 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2001 Hiroyuki Yamamoto
+ *
+ * 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 <glib.h>
+#include <string.h>
+
+#include "stringtable.h"
+#include "utils.h"
+
+/* alfons - hashed string table (I wasn't content with GStringChunk;
+ * can't recall why :-) */
+
+#if 0
+#define XXX_DEBUG \
+ debug_print
+#else
+#define XXX_DEBUG \
+ if (0) debug_print
+#endif
+
+typedef struct StringEntry_ {
+ gint ref_count;
+ gchar *string;
+} StringEntry;
+
+static StringEntry *string_entry_new(const gchar *str)
+{
+ StringEntry *entry;
+
+ entry = g_new0(StringEntry, 1);
+ entry->ref_count = 1;
+ entry->string = g_strdup(str);
+ return entry;
+}
+
+static void string_entry_free(StringEntry *entry)
+{
+ g_return_if_fail(entry != NULL);
+
+ g_free(entry->string);
+ g_free(entry);
+}
+
+StringTable *string_table_new(void)
+{
+ StringTable *strtable;
+
+ strtable = g_new0(StringTable, 1);
+ g_return_val_if_fail(strtable != NULL, NULL);
+ strtable->hash_table = g_hash_table_new(g_str_hash, g_str_equal);
+ g_return_val_if_fail(strtable->hash_table, NULL);
+ return strtable;
+}
+
+gchar *string_table_lookup_string(StringTable *table, const gchar *str)
+{
+ StringEntry *entry;
+
+ entry = g_hash_table_lookup(table->hash_table, str);
+
+ if (entry) {
+ return entry->string;
+ } else {
+ return NULL;
+ }
+}
+
+gchar *string_table_insert_string(StringTable *table, const gchar *str)
+{
+ StringEntry *entry;
+
+ entry = g_hash_table_lookup(table->hash_table, str);
+
+ if (entry) {
+ entry->ref_count++;
+ XXX_DEBUG ("ref++ for %s (%d)\n", entry->string,
+ entry->ref_count);
+ } else {
+ entry = string_entry_new(str);
+ XXX_DEBUG ("inserting %s\n", str);
+ /* insert entry->string instead of str, since it can be
+ * invalid pointer after this. */
+ g_hash_table_insert(table->hash_table, entry->string, entry);
+ }
+
+ return entry->string;
+}
+
+void string_table_free_string(StringTable *table, const gchar *str)
+{
+ StringEntry *entry;
+
+ entry = g_hash_table_lookup(table->hash_table, str);
+
+ if (entry) {
+ entry->ref_count--;
+ if (entry->ref_count <= 0) {
+ XXX_DEBUG ("refcount of string %s dropped to zero\n",
+ entry->string);
+ g_hash_table_remove(table->hash_table, str);
+ string_entry_free(entry);
+ } else {
+ XXX_DEBUG ("ref-- for %s (%d)\n", entry->string,
+ entry->ref_count);
+ }
+ }
+}
+
+static gboolean string_table_remove_for_each_fn(gchar *key, StringEntry *entry,
+ gpointer user_data)
+{
+ g_return_val_if_fail(key != NULL, TRUE);
+ g_return_val_if_fail(entry != NULL, TRUE);
+
+ string_entry_free(entry);
+
+ return TRUE;
+}
+
+void string_table_free(StringTable *table)
+{
+ g_return_if_fail(table != NULL);
+ g_return_if_fail(table->hash_table != NULL);
+
+ g_hash_table_foreach_remove(table->hash_table,
+ (GHRFunc)string_table_remove_for_each_fn,
+ NULL);
+ g_hash_table_destroy(table->hash_table);
+ g_free(table);
+}
+
+static void string_table_stats_for_each_fn(gchar *key, StringEntry *entry,
+ guint *totals)
+{
+ if (entry->ref_count > 1) {
+ *totals += strlen(key) * (entry->ref_count - 1);
+ }
+}
+
+void string_table_get_stats(StringTable *table)
+{
+ guint totals = 0;
+
+ g_hash_table_foreach(table->hash_table,
+ (GHFunc)string_table_stats_for_each_fn, &totals);
+ XXX_DEBUG ("TOTAL UNSPILLED %d (%dK)\n", totals, totals / 1024);
+}
diff --git a/libsylph/stringtable.h b/libsylph/stringtable.h
new file mode 100644
index 00000000..337ef2c7
--- /dev/null
+++ b/libsylph/stringtable.h
@@ -0,0 +1,38 @@
+/*
+ * sylpheed -- a gtk+ based, lightweight, and fast e-mail client
+ * copyright (c) 1999-2001 hiroyuki yamamoto
+ *
+ * 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.
+ */
+
+#ifndef STRINGTABLE_H__
+#define STRINGTABLE_H__
+
+#include <glib.h>
+
+typedef struct {
+ GHashTable *hash_table;
+} StringTable;
+
+StringTable *string_table_new (void);
+void string_table_free (StringTable *table);
+
+gchar *string_table_lookup_string (StringTable *table, const gchar *str);
+gchar *string_table_insert_string (StringTable *table, const gchar *str);
+void string_table_free_string (StringTable *table, const gchar *str);
+
+void string_table_get_stats (StringTable *table);
+
+#endif /* STRINGTABLE_H__ */
diff --git a/libsylph/unmime.c b/libsylph/unmime.c
new file mode 100644
index 00000000..23d787a3
--- /dev/null
+++ b/libsylph/unmime.c
@@ -0,0 +1,134 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "codeconv.h"
+#include "base64.h"
+#include "quoted-printable.h"
+
+#define ENCODED_WORD_BEGIN "=?"
+#define ENCODED_WORD_END "?="
+
+/* Decodes headers based on RFC2045 and RFC2047. */
+
+gchar *unmime_header(const gchar *encoded_str)
+{
+ const gchar *p = encoded_str;
+ const gchar *eword_begin_p, *encoding_begin_p, *text_begin_p,
+ *eword_end_p;
+ gchar charset[32];
+ gchar encoding;
+ gchar *conv_str;
+ GString *outbuf;
+ gchar *out_str;
+ gsize out_len;
+
+ outbuf = g_string_sized_new(strlen(encoded_str) * 2);
+
+ while (*p != '\0') {
+ gchar *decoded_text = NULL;
+ gint len;
+
+ eword_begin_p = strstr(p, ENCODED_WORD_BEGIN);
+ if (!eword_begin_p) {
+ g_string_append(outbuf, p);
+ break;
+ }
+ encoding_begin_p = strchr(eword_begin_p + 2, '?');
+ if (!encoding_begin_p) {
+ g_string_append(outbuf, p);
+ break;
+ }
+ text_begin_p = strchr(encoding_begin_p + 1, '?');
+ if (!text_begin_p) {
+ g_string_append(outbuf, p);
+ break;
+ }
+ eword_end_p = strstr(text_begin_p + 1, ENCODED_WORD_END);
+ if (!eword_end_p) {
+ g_string_append(outbuf, p);
+ break;
+ }
+
+ if (p == encoded_str) {
+ g_string_append_len(outbuf, p, eword_begin_p - p);
+ p = eword_begin_p;
+ } else {
+ /* ignore spaces between encoded words */
+ const gchar *sp;
+
+ for (sp = p; sp < eword_begin_p; sp++) {
+ if (!g_ascii_isspace(*sp)) {
+ g_string_append_len
+ (outbuf, p, eword_begin_p - p);
+ p = eword_begin_p;
+ break;
+ }
+ }
+ }
+
+ len = MIN(sizeof(charset) - 1,
+ encoding_begin_p - (eword_begin_p + 2));
+ memcpy(charset, eword_begin_p + 2, len);
+ charset[len] = '\0';
+ encoding = g_ascii_toupper(*(encoding_begin_p + 1));
+
+ if (encoding == 'B') {
+ decoded_text = g_malloc
+ (eword_end_p - (text_begin_p + 1) + 1);
+ len = base64_decode(decoded_text, text_begin_p + 1,
+ eword_end_p - (text_begin_p + 1));
+ decoded_text[len] = '\0';
+ } else if (encoding == 'Q') {
+ decoded_text = g_malloc
+ (eword_end_p - (text_begin_p + 1) + 1);
+ len = qp_decode_q_encoding
+ (decoded_text, text_begin_p + 1,
+ eword_end_p - (text_begin_p + 1));
+ } else {
+ g_string_append_len(outbuf, p, eword_end_p + 2 - p);
+ p = eword_end_p + 2;
+ continue;
+ }
+
+ /* convert to UTF-8 */
+ conv_str = conv_codeset_strdup(decoded_text, charset, NULL);
+ if (!conv_str)
+ conv_str = conv_utf8todisp(decoded_text, NULL);
+ g_string_append(outbuf, conv_str);
+ g_free(conv_str);
+
+ g_free(decoded_text);
+
+ p = eword_end_p + 2;
+ }
+
+ out_str = outbuf->str;
+ out_len = outbuf->len;
+ g_string_free(outbuf, FALSE);
+
+ return g_realloc(out_str, out_len + 1);
+}
diff --git a/libsylph/unmime.h b/libsylph/unmime.h
new file mode 100644
index 00000000..be9f390e
--- /dev/null
+++ b/libsylph/unmime.h
@@ -0,0 +1,27 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __UNMIME_H__
+#define __UNMIME_H__
+
+#include <glib.h>
+
+gchar *unmime_header (const gchar *encoded_str);
+
+#endif /* __UNMIME_H__ */
diff --git a/libsylph/utils.c b/libsylph/utils.c
new file mode 100644
index 00000000..dc72b814
--- /dev/null
+++ b/libsylph/utils.c
@@ -0,0 +1,3436 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "defs.h"
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
+# include <wchar.h>
+# include <wctype.h>
+#endif
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#if HAVE_SYS_WAIT_H
+# include <sys/wait.h>
+#endif
+#include <dirent.h>
+#include <time.h>
+
+#ifdef G_OS_WIN32
+# include <direct.h>
+# include <io.h>
+#endif
+
+#include "utils.h"
+#include "socket.h"
+
+#define BUFFSIZE 8192
+
+static gboolean debug_mode = FALSE;
+
+
+#if !GLIB_CHECK_VERSION(2, 7, 0) && !defined(G_OS_UNIX)
+gint g_chdir(const gchar *path)
+{
+#ifdef G_OS_WIN32
+ if (G_WIN32_HAVE_WIDECHAR_API()) {
+ wchar_t *wpath;
+ gint retval;
+ gint save_errno;
+
+ wpath = g_utf8_to_utf16(path, -1, NULL, NULL, NULL);
+ if (wpath == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ retval = _wchdir(wpath);
+ save_errno = errno;
+
+ g_free(wpath);
+
+ errno = save_errno;
+ return retval;
+ } else {
+ gchar *cp_path;
+ gint retval;
+ gint save_errno;
+
+ cp_path = g_locale_from_utf8(path, -1, NULL, NULL, NULL);
+ if (cp_path == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ retval = chdir(cp_path);
+ save_errno = errno;
+
+ g_free(cp_path);
+
+ errno = save_errno;
+ return retval;
+ }
+#else
+ return chdir(path);
+#endif
+}
+
+gint g_chmod(const gchar *path, gint mode)
+{
+#ifdef G_OS_WIN32
+ if (G_WIN32_HAVE_WIDECHAR_API()) {
+ wchar_t *wpath;
+ gint retval;
+ gint save_errno;
+
+ wpath = g_utf8_to_utf16(path, -1, NULL, NULL, NULL);
+ if (wpath == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ retval = _wchmod(wpath, mode);
+ save_errno = errno;
+
+ g_free(wpath);
+
+ errno = save_errno;
+ return retval;
+ } else {
+ gchar *cp_path;
+ gint retval;
+ gint save_errno;
+
+ cp_path = g_locale_from_utf8(path, -1, NULL, NULL, NULL);
+ if (cp_path == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ retval = chmod(cp_path, mode);
+ save_errno = errno;
+
+ g_free(cp_path);
+
+ errno = save_errno;
+ return retval;
+ }
+#else
+ return chmod(path, mode);
+#endif
+}
+#endif /* GLIB_CHECK_VERSION && G_OS_UNIX */
+
+void list_free_strings(GList *list)
+{
+ list = g_list_first(list);
+
+ while (list != NULL) {
+ g_free(list->data);
+ list = list->next;
+ }
+}
+
+void slist_free_strings(GSList *list)
+{
+ while (list != NULL) {
+ g_free(list->data);
+ list = list->next;
+ }
+}
+
+static void hash_free_strings_func(gpointer key, gpointer value, gpointer data)
+{
+ g_free(key);
+}
+
+void hash_free_strings(GHashTable *table)
+{
+ g_hash_table_foreach(table, hash_free_strings_func, NULL);
+}
+
+static void hash_free_value_mem_func(gpointer key, gpointer value,
+ gpointer data)
+{
+ g_free(value);
+}
+
+void hash_free_value_mem(GHashTable *table)
+{
+ g_hash_table_foreach(table, hash_free_value_mem_func, NULL);
+}
+
+gint str_case_equal(gconstpointer v, gconstpointer v2)
+{
+ return g_ascii_strcasecmp((const gchar *)v, (const gchar *)v2) == 0;
+}
+
+guint str_case_hash(gconstpointer key)
+{
+ const gchar *p = key;
+ guint h = *p;
+
+ if (h) {
+ h = g_ascii_tolower(h);
+ for (p += 1; *p != '\0'; p++)
+ h = (h << 5) - h + g_ascii_tolower(*p);
+ }
+
+ return h;
+}
+
+void ptr_array_free_strings(GPtrArray *array)
+{
+ gint i;
+ gchar *str;
+
+ g_return_if_fail(array != NULL);
+
+ for (i = 0; i < array->len; i++) {
+ str = g_ptr_array_index(array, i);
+ g_free(str);
+ }
+}
+
+gboolean str_find(const gchar *haystack, const gchar *needle)
+{
+ return strstr(haystack, needle) != NULL ? TRUE : FALSE;
+}
+
+gboolean str_case_find(const gchar *haystack, const gchar *needle)
+{
+ return strcasestr(haystack, needle) != NULL ? TRUE : FALSE;
+}
+
+gboolean str_find_equal(const gchar *haystack, const gchar *needle)
+{
+ return strcmp(haystack, needle) == 0;
+}
+
+gboolean str_case_find_equal(const gchar *haystack, const gchar *needle)
+{
+ return g_ascii_strcasecmp(haystack, needle) == 0;
+}
+
+gint to_number(const gchar *nstr)
+{
+ register const gchar *p;
+
+ if (*nstr == '\0') return -1;
+
+ for (p = nstr; *p != '\0'; p++)
+ if (!g_ascii_isdigit(*p)) return -1;
+
+ return atoi(nstr);
+}
+
+/* convert integer into string,
+ nstr must be not lower than 11 characters length */
+gchar *itos_buf(gchar *nstr, gint n)
+{
+ g_snprintf(nstr, 11, "%d", n);
+ return nstr;
+}
+
+/* convert integer into string */
+gchar *itos(gint n)
+{
+ static gchar nstr[11];
+
+ return itos_buf(nstr, n);
+}
+
+gchar *to_human_readable(off_t size)
+{
+ static gchar str[10];
+
+ if (size < 1024)
+ g_snprintf(str, sizeof(str), _("%dB"), (gint)size);
+ else if (size >> 10 < 1024)
+ g_snprintf(str, sizeof(str), _("%.1fKB"), (gfloat)size / (1 << 10));
+ else if (size >> 20 < 1024)
+ g_snprintf(str, sizeof(str), _("%.2fMB"), (gfloat)size / (1 << 20));
+ else
+ g_snprintf(str, sizeof(str), _("%.2fGB"), (gfloat)size / (1 << 30));
+
+ return str;
+}
+
+/* strcmp with NULL-checking */
+gint strcmp2(const gchar *s1, const gchar *s2)
+{
+ if (s1 == NULL || s2 == NULL)
+ return -1;
+ else
+ return strcmp(s1, s2);
+}
+
+/* compare paths */
+gint path_cmp(const gchar *s1, const gchar *s2)
+{
+ gint len1, len2;
+#ifdef G_OS_WIN32
+ gchar *s1_, *s2_;
+#endif
+
+ if (s1 == NULL || s2 == NULL) return -1;
+ if (*s1 == '\0' || *s2 == '\0') return -1;
+
+ len1 = strlen(s1);
+ len2 = strlen(s2);
+
+#ifdef G_OS_WIN32
+ Xstrdup_a(s1_, s1, return -1);
+ Xstrdup_a(s2_, s2, return -1);
+ subst_char(s1_, '/', G_DIR_SEPARATOR);
+ subst_char(s2_, '/', G_DIR_SEPARATOR);
+ if (s1_[len1 - 1] == G_DIR_SEPARATOR) len1--;
+ if (s2_[len2 - 1] == G_DIR_SEPARATOR) len2--;
+
+ return strncmp(s1_, s2_, MAX(len1, len2));
+#else
+ if (s1[len1 - 1] == G_DIR_SEPARATOR) len1--;
+ if (s2[len2 - 1] == G_DIR_SEPARATOR) len2--;
+
+ return strncmp(s1, s2, MAX(len1, len2));
+#endif
+}
+
+/* remove trailing return code */
+gchar *strretchomp(gchar *str)
+{
+ register gchar *s;
+
+ if (!*str) return str;
+
+ for (s = str + strlen(str) - 1;
+ s >= str && (*s == '\n' || *s == '\r');
+ s--)
+ *s = '\0';
+
+ return str;
+}
+
+/* remove trailing character */
+gchar *strtailchomp(gchar *str, gchar tail_char)
+{
+ register gchar *s;
+
+ if (!*str) return str;
+ if (tail_char == '\0') return str;
+
+ for (s = str + strlen(str) - 1; s >= str && *s == tail_char; s--)
+ *s = '\0';
+
+ return str;
+}
+
+/* remove CR (carriage return) */
+gchar *strcrchomp(gchar *str)
+{
+ register gchar *s;
+
+ if (!*str) return str;
+
+ s = str + strlen(str) - 1;
+ if (*s == '\n' && s > str && *(s - 1) == '\r') {
+ *(s - 1) = '\n';
+ *s = '\0';
+ }
+
+ return str;
+}
+
+/* Similar to `strstr' but this function ignores the case of both strings. */
+gchar *strcasestr(const gchar *haystack, const gchar *needle)
+{
+ register size_t haystack_len, needle_len;
+
+ haystack_len = strlen(haystack);
+ needle_len = strlen(needle);
+
+ if (haystack_len < needle_len || needle_len == 0)
+ return NULL;
+
+ while (haystack_len >= needle_len) {
+ if (!g_ascii_strncasecmp(haystack, needle, needle_len))
+ return (gchar *)haystack;
+ else {
+ haystack++;
+ haystack_len--;
+ }
+ }
+
+ return NULL;
+}
+
+gpointer my_memmem(gconstpointer haystack, size_t haystacklen,
+ gconstpointer needle, size_t needlelen)
+{
+ const gchar *haystack_ = (const gchar *)haystack;
+ const gchar *needle_ = (const gchar *)needle;
+ const gchar *haystack_cur = (const gchar *)haystack;
+
+ if (needlelen == 1)
+ return memchr(haystack_, *needle_, haystacklen);
+
+ while ((haystack_cur = memchr(haystack_cur, *needle_, haystacklen))
+ != NULL) {
+ if (haystacklen - (haystack_cur - haystack_) < needlelen)
+ break;
+ if (memcmp(haystack_cur + 1, needle_ + 1, needlelen - 1) == 0)
+ return (gpointer)haystack_cur;
+ else
+ haystack_cur++;
+ }
+
+ return NULL;
+}
+
+/* Copy no more than N characters of SRC to DEST, with NULL terminating. */
+gchar *strncpy2(gchar *dest, const gchar *src, size_t n)
+{
+ register const gchar *s = src;
+ register gchar *d = dest;
+
+ while (--n && *s)
+ *d++ = *s++;
+ *d = '\0';
+
+ return dest;
+}
+
+#if !HAVE_ISWALNUM
+int iswalnum(wint_t wc)
+{
+ return g_ascii_isalnum((int)wc);
+}
+#endif
+
+#if !HAVE_ISWSPACE
+int iswspace(wint_t wc)
+{
+ return g_ascii_isspace((int)wc);
+}
+#endif
+
+#if !HAVE_TOWLOWER
+wint_t towlower(wint_t wc)
+{
+ if (wc >= L'A' && wc <= L'Z')
+ return wc + L'a' - L'A';
+
+ return wc;
+}
+#endif
+
+#if !HAVE_WCSLEN
+size_t wcslen(const wchar_t *s)
+{
+ size_t len = 0;
+
+ while (*s != L'\0')
+ ++len, ++s;
+
+ return len;
+}
+#endif
+
+#if !HAVE_WCSCPY
+/* Copy SRC to DEST. */
+wchar_t *wcscpy(wchar_t *dest, const wchar_t *src)
+{
+ wint_t c;
+ wchar_t *s = dest;
+
+ do {
+ c = *src++;
+ *dest++ = c;
+ } while (c != L'\0');
+
+ return s;
+}
+#endif
+
+#if !HAVE_WCSNCPY
+/* Copy no more than N wide-characters of SRC to DEST. */
+wchar_t *wcsncpy (wchar_t *dest, const wchar_t *src, size_t n)
+{
+ wint_t c;
+ wchar_t *s = dest;
+
+ do {
+ c = *src++;
+ *dest++ = c;
+ if (--n == 0)
+ return s;
+ } while (c != L'\0');
+
+ /* zero fill */
+ do
+ *dest++ = L'\0';
+ while (--n > 0);
+
+ return s;
+}
+#endif
+
+/* Duplicate S, returning an identical malloc'd string. */
+wchar_t *wcsdup(const wchar_t *s)
+{
+ wchar_t *new_str;
+
+ if (s) {
+ new_str = g_new(wchar_t, wcslen(s) + 1);
+ wcscpy(new_str, s);
+ } else
+ new_str = NULL;
+
+ return new_str;
+}
+
+/* Duplicate no more than N wide-characters of S,
+ returning an identical malloc'd string. */
+wchar_t *wcsndup(const wchar_t *s, size_t n)
+{
+ wchar_t *new_str;
+
+ if (s) {
+ new_str = g_new(wchar_t, n + 1);
+ wcsncpy(new_str, s, n);
+ new_str[n] = (wchar_t)0;
+ } else
+ new_str = NULL;
+
+ return new_str;
+}
+
+wchar_t *strdup_mbstowcs(const gchar *s)
+{
+ wchar_t *new_str;
+
+ if (s) {
+ new_str = g_new(wchar_t, strlen(s) + 1);
+ if (mbstowcs(new_str, s, strlen(s) + 1) < 0) {
+ g_free(new_str);
+ new_str = NULL;
+ } else
+ new_str = g_realloc(new_str,
+ sizeof(wchar_t) * (wcslen(new_str) + 1));
+ } else
+ new_str = NULL;
+
+ return new_str;
+}
+
+gchar *strdup_wcstombs(const wchar_t *s)
+{
+ gchar *new_str;
+ size_t len;
+
+ if (s) {
+ len = wcslen(s) * MB_CUR_MAX + 1;
+ new_str = g_new(gchar, len);
+ if (wcstombs(new_str, s, len) < 0) {
+ g_free(new_str);
+ new_str = NULL;
+ } else
+ new_str = g_realloc(new_str, strlen(new_str) + 1);
+ } else
+ new_str = NULL;
+
+ return new_str;
+}
+
+/* Compare S1 and S2, ignoring case. */
+gint wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n)
+{
+ wint_t c1;
+ wint_t c2;
+
+ while (n--) {
+ c1 = towlower(*s1++);
+ c2 = towlower(*s2++);
+ if (c1 != c2)
+ return c1 - c2;
+ else if (c1 == 0 && c2 == 0)
+ break;
+ }
+
+ return 0;
+}
+
+/* Find the first occurrence of NEEDLE in HAYSTACK, ignoring case. */
+wchar_t *wcscasestr(const wchar_t *haystack, const wchar_t *needle)
+{
+ register size_t haystack_len, needle_len;
+
+ haystack_len = wcslen(haystack);
+ needle_len = wcslen(needle);
+
+ if (haystack_len < needle_len || needle_len == 0)
+ return NULL;
+
+ while (haystack_len >= needle_len) {
+ if (!wcsncasecmp(haystack, needle, needle_len))
+ return (wchar_t *)haystack;
+ else {
+ haystack++;
+ haystack_len--;
+ }
+ }
+
+ return NULL;
+}
+
+gint get_mbs_len(const gchar *s)
+{
+ const gchar *p = s;
+ gint mb_len;
+ gint len = 0;
+
+ if (!p)
+ return -1;
+
+ while (*p != '\0') {
+ mb_len = g_utf8_skip[*(guchar *)p];
+ if (mb_len == 0)
+ break;
+ else
+ len++;
+
+ p += mb_len;
+ }
+
+ return len;
+}
+
+/* Examine if next block is non-ASCII string */
+gboolean is_next_nonascii(const gchar *s)
+{
+ const gchar *p;
+
+ /* skip head space */
+ for (p = s; *p != '\0' && g_ascii_isspace(*p); p++)
+ ;
+ for (; *p != '\0' && !g_ascii_isspace(*p); p++) {
+ if (*(guchar *)p > 127 || *(guchar *)p < 32)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gint get_next_word_len(const gchar *s)
+{
+ gint len = 0;
+
+ for (; *s != '\0' && !g_ascii_isspace(*s); s++, len++)
+ ;
+
+ return len;
+}
+
+/* compare subjects */
+gint subject_compare(const gchar *s1, const gchar *s2)
+{
+ gchar *str1, *str2;
+
+ if (!s1 || !s2) return -1;
+ if (!*s1 || !*s2) return -1;
+
+ Xstrdup_a(str1, s1, return -1);
+ Xstrdup_a(str2, s2, return -1);
+
+ trim_subject_for_compare(str1);
+ trim_subject_for_compare(str2);
+
+ if (!*str1 || !*str2) return -1;
+
+ return strcmp(str1, str2);
+}
+
+gint subject_compare_for_sort(const gchar *s1, const gchar *s2)
+{
+ gchar *str1, *str2;
+
+ if (!s1 || !s2) return -1;
+
+ Xstrdup_a(str1, s1, return -1);
+ Xstrdup_a(str2, s2, return -1);
+
+ trim_subject_for_sort(str1);
+ trim_subject_for_sort(str2);
+
+ return g_ascii_strcasecmp(str1, str2);
+}
+
+void trim_subject_for_compare(gchar *str)
+{
+ gchar *srcp;
+
+ eliminate_parenthesis(str, '[', ']');
+ eliminate_parenthesis(str, '(', ')');
+ g_strstrip(str);
+
+ while (!g_ascii_strncasecmp(str, "Re:", 3)) {
+ srcp = str + 3;
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(str, srcp, strlen(srcp) + 1);
+ }
+}
+
+void trim_subject_for_sort(gchar *str)
+{
+ gchar *srcp;
+
+ g_strstrip(str);
+
+ while (!g_ascii_strncasecmp(str, "Re:", 3)) {
+ srcp = str + 3;
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(str, srcp, strlen(srcp) + 1);
+ }
+}
+
+void trim_subject(gchar *str)
+{
+ register gchar *srcp, *destp;
+ gchar op, cl;
+ gint in_brace;
+
+ destp = str;
+ while (!g_ascii_strncasecmp(destp, "Re:", 3)) {
+ destp += 3;
+ while (g_ascii_isspace(*destp)) destp++;
+ }
+
+ if (*destp == '[') {
+ op = '[';
+ cl = ']';
+ } else if (*destp == '(') {
+ op = '(';
+ cl = ')';
+ } else
+ return;
+
+ srcp = destp + 1;
+ in_brace = 1;
+ while (*srcp) {
+ if (*srcp == op)
+ in_brace++;
+ else if (*srcp == cl)
+ in_brace--;
+ srcp++;
+ if (in_brace == 0)
+ break;
+ }
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(destp, srcp, strlen(srcp) + 1);
+}
+
+void eliminate_parenthesis(gchar *str, gchar op, gchar cl)
+{
+ register gchar *srcp, *destp;
+ gint in_brace;
+
+ srcp = destp = str;
+
+ while ((destp = strchr(destp, op))) {
+ in_brace = 1;
+ srcp = destp + 1;
+ while (*srcp) {
+ if (*srcp == op)
+ in_brace++;
+ else if (*srcp == cl)
+ in_brace--;
+ srcp++;
+ if (in_brace == 0)
+ break;
+ }
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(destp, srcp, strlen(srcp) + 1);
+ }
+}
+
+void extract_parenthesis(gchar *str, gchar op, gchar cl)
+{
+ register gchar *srcp, *destp;
+ gint in_brace;
+
+ srcp = destp = str;
+
+ while ((srcp = strchr(destp, op))) {
+ if (destp > str)
+ *destp++ = ' ';
+ memmove(destp, srcp + 1, strlen(srcp));
+ in_brace = 1;
+ while(*destp) {
+ if (*destp == op)
+ in_brace++;
+ else if (*destp == cl)
+ in_brace--;
+
+ if (in_brace == 0)
+ break;
+
+ destp++;
+ }
+ }
+ *destp = '\0';
+}
+
+void extract_parenthesis_with_skip_quote(gchar *str, gchar quote_chr,
+ gchar op, gchar cl)
+{
+ register gchar *srcp, *destp;
+ gint in_brace;
+ gboolean in_quote = FALSE;
+
+ srcp = destp = str;
+
+ while ((srcp = strchr_with_skip_quote(destp, quote_chr, op))) {
+ if (destp > str)
+ *destp++ = ' ';
+ memmove(destp, srcp + 1, strlen(srcp));
+ in_brace = 1;
+ while(*destp) {
+ if (*destp == op && !in_quote)
+ in_brace++;
+ else if (*destp == cl && !in_quote)
+ in_brace--;
+ else if (*destp == quote_chr)
+ in_quote ^= TRUE;
+
+ if (in_brace == 0)
+ break;
+
+ destp++;
+ }
+ }
+ *destp = '\0';
+}
+
+void eliminate_quote(gchar *str, gchar quote_chr)
+{
+ register gchar *srcp, *destp;
+
+ srcp = destp = str;
+
+ while ((destp = strchr(destp, quote_chr))) {
+ if ((srcp = strchr(destp + 1, quote_chr))) {
+ srcp++;
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(destp, srcp, strlen(srcp) + 1);
+ } else {
+ *destp = '\0';
+ break;
+ }
+ }
+}
+
+void extract_quote(gchar *str, gchar quote_chr)
+{
+ register gchar *p;
+
+ if ((str = strchr(str, quote_chr))) {
+ if ((p = strchr(str + 1, quote_chr))) {
+ *p = '\0';
+ memmove(str, str + 1, p - str);
+ }
+ }
+}
+
+void eliminate_address_comment(gchar *str)
+{
+ register gchar *srcp, *destp;
+ gint in_brace;
+
+ srcp = destp = str;
+
+ while ((destp = strchr(destp, '"'))) {
+ if ((srcp = strchr(destp + 1, '"'))) {
+ srcp++;
+ if (*srcp == '@') {
+ destp = srcp + 1;
+ } else {
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(destp, srcp, strlen(srcp) + 1);
+ }
+ } else {
+ *destp = '\0';
+ break;
+ }
+ }
+
+ srcp = destp = str;
+
+ while ((destp = strchr_with_skip_quote(destp, '"', '('))) {
+ in_brace = 1;
+ srcp = destp + 1;
+ while (*srcp) {
+ if (*srcp == '(')
+ in_brace++;
+ else if (*srcp == ')')
+ in_brace--;
+ srcp++;
+ if (in_brace == 0)
+ break;
+ }
+ while (g_ascii_isspace(*srcp)) srcp++;
+ memmove(destp, srcp, strlen(srcp) + 1);
+ }
+}
+
+gchar *strchr_with_skip_quote(const gchar *str, gint quote_chr, gint c)
+{
+ gboolean in_quote = FALSE;
+
+ while (*str) {
+ if (*str == c && !in_quote)
+ return (gchar *)str;
+ if (*str == quote_chr)
+ in_quote ^= TRUE;
+ str++;
+ }
+
+ return NULL;
+}
+
+gchar *strrchr_with_skip_quote(const gchar *str, gint quote_chr, gint c)
+{
+ gboolean in_quote = FALSE;
+ const gchar *p;
+
+ p = str + strlen(str) - 1;
+ while (p >= str) {
+ if (*p == c && !in_quote)
+ return (gchar *)p;
+ if (*p == quote_chr)
+ in_quote ^= TRUE;
+ p--;
+ }
+
+ return NULL;
+}
+
+void extract_address(gchar *str)
+{
+ eliminate_address_comment(str);
+ if (strchr_with_skip_quote(str, '"', '<'))
+ extract_parenthesis_with_skip_quote(str, '"', '<', '>');
+ g_strstrip(str);
+}
+
+void extract_list_id_str(gchar *str)
+{
+ if (strchr_with_skip_quote(str, '"', '<'))
+ extract_parenthesis_with_skip_quote(str, '"', '<', '>');
+ g_strstrip(str);
+}
+
+GSList *address_list_append(GSList *addr_list, const gchar *str)
+{
+ gchar *work;
+ gchar *workp;
+
+ if (!str) return addr_list;
+
+ Xstrdup_a(work, str, return addr_list);
+
+ eliminate_address_comment(work);
+ workp = work;
+
+ while (workp && *workp) {
+ gchar *p, *next;
+
+ if ((p = strchr_with_skip_quote(workp, '"', ','))) {
+ *p = '\0';
+ next = p + 1;
+ } else
+ next = NULL;
+
+ if (strchr_with_skip_quote(workp, '"', '<'))
+ extract_parenthesis_with_skip_quote
+ (workp, '"', '<', '>');
+
+ g_strstrip(workp);
+ if (*workp)
+ addr_list = g_slist_append(addr_list, g_strdup(workp));
+
+ workp = next;
+ }
+
+ return addr_list;
+}
+
+GSList *references_list_prepend(GSList *msgid_list, const gchar *str)
+{
+ const gchar *strp;
+
+ if (!str) return msgid_list;
+ strp = str;
+
+ while (strp && *strp) {
+ const gchar *start, *end;
+ gchar *msgid;
+
+ if ((start = strchr(strp, '<')) != NULL) {
+ end = strchr(start + 1, '>');
+ if (!end) break;
+ } else
+ break;
+
+ msgid = g_strndup(start + 1, end - start - 1);
+ g_strstrip(msgid);
+ if (*msgid)
+ msgid_list = g_slist_prepend(msgid_list, msgid);
+ else
+ g_free(msgid);
+
+ strp = end + 1;
+ }
+
+ return msgid_list;
+}
+
+GSList *references_list_append(GSList *msgid_list, const gchar *str)
+{
+ GSList *list;
+
+ list = references_list_prepend(NULL, str);
+ list = g_slist_reverse(list);
+ msgid_list = g_slist_concat(msgid_list, list);
+
+ return msgid_list;
+}
+
+GSList *newsgroup_list_append(GSList *group_list, const gchar *str)
+{
+ gchar *work;
+ gchar *workp;
+
+ if (!str) return group_list;
+
+ Xstrdup_a(work, str, return group_list);
+
+ workp = work;
+
+ while (workp && *workp) {
+ gchar *p, *next;
+
+ if ((p = strchr_with_skip_quote(workp, '"', ','))) {
+ *p = '\0';
+ next = p + 1;
+ } else
+ next = NULL;
+
+ g_strstrip(workp);
+ if (*workp)
+ group_list = g_slist_append(group_list,
+ g_strdup(workp));
+
+ workp = next;
+ }
+
+ return group_list;
+}
+
+GList *add_history(GList *list, const gchar *str)
+{
+ GList *old;
+
+ g_return_val_if_fail(str != NULL, list);
+
+ old = g_list_find_custom(list, (gpointer)str, (GCompareFunc)strcmp2);
+ if (old) {
+ g_free(old->data);
+ list = g_list_remove(list, old->data);
+ } else if (g_list_length(list) >= MAX_HISTORY_SIZE) {
+ GList *last;
+
+ last = g_list_last(list);
+ if (last) {
+ g_free(last->data);
+ g_list_remove(list, last->data);
+ }
+ }
+
+ list = g_list_prepend(list, g_strdup(str));
+
+ return list;
+}
+
+void remove_return(gchar *str)
+{
+ register gchar *p = str;
+
+ while (*p) {
+ if (*p == '\n' || *p == '\r')
+ memmove(p, p + 1, strlen(p));
+ else
+ p++;
+ }
+}
+
+void remove_space(gchar *str)
+{
+ register gchar *p = str;
+ register gint spc;
+
+ while (*p) {
+ spc = 0;
+ while (g_ascii_isspace(*(p + spc)))
+ spc++;
+ if (spc)
+ memmove(p, p + spc, strlen(p + spc) + 1);
+ else
+ p++;
+ }
+}
+
+void unfold_line(gchar *str)
+{
+ register gchar *p = str;
+ register gint spc;
+
+ while (*p) {
+ if (*p == '\n' || *p == '\r') {
+ *p++ = ' ';
+ spc = 0;
+ while (g_ascii_isspace(*(p + spc)))
+ spc++;
+ if (spc)
+ memmove(p, p + spc, strlen(p + spc) + 1);
+ } else
+ p++;
+ }
+}
+
+void subst_char(gchar *str, gchar orig, gchar subst)
+{
+ register gchar *p = str;
+
+ while (*p) {
+ if (*p == orig)
+ *p = subst;
+ p++;
+ }
+}
+
+void subst_chars(gchar *str, gchar *orig, gchar subst)
+{
+ register gchar *p = str;
+
+ while (*p) {
+ if (strchr(orig, *p) != NULL)
+ *p = subst;
+ p++;
+ }
+}
+
+void subst_null(gchar *str, gint len, gchar subst)
+{
+ register gchar *p = str;
+
+ while (len--) {
+ if (*p == '\0')
+ *p = subst;
+ p++;
+ }
+}
+
+void subst_for_filename(gchar *str)
+{
+ subst_chars(str, " \t\r\n\"'/\\", '_');
+}
+
+gboolean is_header_line(const gchar *str)
+{
+ if (str[0] == ':') return FALSE;
+
+ while (*str != '\0' && *str != ' ') {
+ if (*str == ':')
+ return TRUE;
+ str++;
+ }
+
+ return FALSE;
+}
+
+gboolean is_ascii_str(const gchar *str)
+{
+ const guchar *p = (const guchar *)str;
+
+ while (*p != '\0') {
+ if (*p != '\t' && *p != ' ' &&
+ *p != '\r' && *p != '\n' &&
+ (*p < 32 || *p >= 127))
+ return FALSE;
+ p++;
+ }
+
+ return TRUE;
+}
+
+gint get_quote_level(const gchar *str)
+{
+ const gchar *first_pos;
+ const gchar *last_pos;
+ const gchar *p = str;
+ gint quote_level = -1;
+
+ /* speed up line processing by only searching to the last '>' */
+ if ((first_pos = strchr(str, '>')) != NULL) {
+ /* skip a line if it contains a '<' before the initial '>' */
+ if (memchr(str, '<', first_pos - str) != NULL)
+ return -1;
+ last_pos = strrchr(first_pos, '>');
+ } else
+ return -1;
+
+ while (p <= last_pos) {
+ while (p < last_pos) {
+ if (g_ascii_isspace(*p))
+ p++;
+ else
+ break;
+ }
+
+ if (*p == '>')
+ quote_level++;
+ else if (*p != '-' && !g_ascii_isspace(*p) && p <= last_pos) {
+ /* any characters are allowed except '-' and space */
+ while (*p != '-' && *p != '>' && !g_ascii_isspace(*p) &&
+ p < last_pos)
+ p++;
+ if (*p == '>')
+ quote_level++;
+ else
+ break;
+ }
+
+ p++;
+ }
+
+ return quote_level;
+}
+
+gint check_line_length(const gchar *str, gint max_chars, gint *line)
+{
+ const gchar *p = str, *q;
+ gint cur_line = 0, len;
+
+ while ((q = strchr(p, '\n')) != NULL) {
+ len = q - p + 1;
+ if (len > max_chars) {
+ if (line)
+ *line = cur_line;
+ return -1;
+ }
+ p = q + 1;
+ ++cur_line;
+ }
+
+ len = strlen(p);
+ if (len > max_chars) {
+ if (line)
+ *line = cur_line;
+ return -1;
+ }
+
+ return 0;
+}
+
+gchar *strstr_with_skip_quote(const gchar *haystack, const gchar *needle)
+{
+ register guint haystack_len, needle_len;
+ gboolean in_squote = FALSE, in_dquote = FALSE;
+
+ haystack_len = strlen(haystack);
+ needle_len = strlen(needle);
+
+ if (haystack_len < needle_len || needle_len == 0)
+ return NULL;
+
+ while (haystack_len >= needle_len) {
+ if (!in_squote && !in_dquote &&
+ !strncmp(haystack, needle, needle_len))
+ return (gchar *)haystack;
+
+ /* 'foo"bar"' -> foo"bar"
+ "foo'bar'" -> foo'bar' */
+ if (*haystack == '\'') {
+ if (in_squote)
+ in_squote = FALSE;
+ else if (!in_dquote)
+ in_squote = TRUE;
+ } else if (*haystack == '\"') {
+ if (in_dquote)
+ in_dquote = FALSE;
+ else if (!in_squote)
+ in_dquote = TRUE;
+ }
+
+ haystack++;
+ haystack_len--;
+ }
+
+ return NULL;
+}
+
+gchar *strchr_parenthesis_close(const gchar *str, gchar op, gchar cl)
+{
+ const gchar *p;
+ gchar quote_chr = '"';
+ gint in_brace;
+ gboolean in_quote = FALSE;
+
+ p = str;
+
+ if ((p = strchr_with_skip_quote(p, quote_chr, op))) {
+ p++;
+ in_brace = 1;
+ while (*p) {
+ if (*p == op && !in_quote)
+ in_brace++;
+ else if (*p == cl && !in_quote)
+ in_brace--;
+ else if (*p == quote_chr)
+ in_quote ^= TRUE;
+
+ if (in_brace == 0)
+ return (gchar *)p;
+
+ p++;
+ }
+ }
+
+ return NULL;
+}
+
+gchar **strsplit_parenthesis(const gchar *str, gchar op, gchar cl,
+ gint max_tokens)
+{
+ GSList *string_list = NULL, *slist;
+ gchar **str_array;
+ const gchar *s_op, *s_cl;
+ guint i, n = 1;
+
+ g_return_val_if_fail(str != NULL, NULL);
+
+ if (max_tokens < 1)
+ max_tokens = G_MAXINT;
+
+ s_op = strchr_with_skip_quote(str, '"', op);
+ if (!s_op) return NULL;
+ str = s_op;
+ s_cl = strchr_parenthesis_close(str, op, cl);
+ if (s_cl) {
+ do {
+ guint len;
+ gchar *new_string;
+
+ str++;
+ len = s_cl - str;
+ new_string = g_new(gchar, len + 1);
+ strncpy(new_string, str, len);
+ new_string[len] = 0;
+ string_list = g_slist_prepend(string_list, new_string);
+ n++;
+ str = s_cl + 1;
+
+ while (*str && g_ascii_isspace(*str)) str++;
+ if (*str != op) {
+ string_list = g_slist_prepend(string_list,
+ g_strdup(""));
+ n++;
+ s_op = strchr_with_skip_quote(str, '"', op);
+ if (!--max_tokens || !s_op) break;
+ str = s_op;
+ } else
+ s_op = str;
+ s_cl = strchr_parenthesis_close(str, op, cl);
+ } while (--max_tokens && s_cl);
+ }
+
+ str_array = g_new(gchar*, n);
+
+ i = n - 1;
+
+ str_array[i--] = NULL;
+ for (slist = string_list; slist; slist = slist->next)
+ str_array[i--] = slist->data;
+
+ g_slist_free(string_list);
+
+ return str_array;
+}
+
+gchar **strsplit_with_quote(const gchar *str, const gchar *delim,
+ gint max_tokens)
+{
+ GSList *string_list = NULL, *slist;
+ gchar **str_array, *s, *new_str;
+ guint i, n = 1, len;
+
+ g_return_val_if_fail(str != NULL, NULL);
+ g_return_val_if_fail(delim != NULL, NULL);
+
+ if (max_tokens < 1)
+ max_tokens = G_MAXINT;
+
+ s = strstr_with_skip_quote(str, delim);
+ if (s) {
+ guint delimiter_len = strlen(delim);
+
+ do {
+ len = s - str;
+ new_str = g_strndup(str, len);
+
+ if (new_str[0] == '\'' || new_str[0] == '\"') {
+ if (new_str[len - 1] == new_str[0]) {
+ new_str[len - 1] = '\0';
+ memmove(new_str, new_str + 1, len - 1);
+ }
+ }
+ string_list = g_slist_prepend(string_list, new_str);
+ n++;
+ str = s + delimiter_len;
+ s = strstr_with_skip_quote(str, delim);
+ } while (--max_tokens && s);
+ }
+
+ if (*str) {
+ new_str = g_strdup(str);
+ if (new_str[0] == '\'' || new_str[0] == '\"') {
+ len = strlen(str);
+ if (new_str[len - 1] == new_str[0]) {
+ new_str[len - 1] = '\0';
+ memmove(new_str, new_str + 1, len - 1);
+ }
+ }
+ string_list = g_slist_prepend(string_list, new_str);
+ n++;
+ }
+
+ str_array = g_new(gchar*, n);
+
+ i = n - 1;
+
+ str_array[i--] = NULL;
+ for (slist = string_list; slist; slist = slist->next)
+ str_array[i--] = slist->data;
+
+ g_slist_free(string_list);
+
+ return str_array;
+}
+
+gchar *get_abbrev_newsgroup_name(const gchar *group, gint len)
+{
+ gchar *abbrev_group;
+ gchar *ap;
+ const gchar *p = group;
+ const gchar *last;
+
+ last = group + strlen(group);
+ abbrev_group = ap = g_malloc(strlen(group) + 1);
+
+ while (*p) {
+ while (*p == '.')
+ *ap++ = *p++;
+ if ((ap - abbrev_group) + (last - p) > len && strchr(p, '.')) {
+ *ap++ = *p++;
+ while (*p != '.') p++;
+ } else {
+ strcpy(ap, p);
+ return abbrev_group;
+ }
+ }
+
+ *ap = '\0';
+ return abbrev_group;
+}
+
+gchar *trim_string(const gchar *str, gint len)
+{
+ const gchar *p = str;
+ gint mb_len;
+ gchar *new_str;
+ gint new_len = 0;
+
+ if (!str) return NULL;
+ if (strlen(str) <= len)
+ return g_strdup(str);
+ if (g_utf8_validate(str, -1, NULL) == FALSE)
+ return g_strdup(str);
+
+ while (*p != '\0') {
+ mb_len = g_utf8_skip[*(guchar *)p];
+ if (mb_len == 0)
+ break;
+ else if (new_len + mb_len > len)
+ break;
+
+ new_len += mb_len;
+ p += mb_len;
+ }
+
+ Xstrndup_a(new_str, str, new_len, return g_strdup(str));
+ return g_strconcat(new_str, "...", NULL);
+}
+
+gchar *trim_string_before(const gchar *str, gint len)
+{
+ const gchar *p = str;
+ gint mb_len;
+ gint new_len;
+
+ if (!str) return NULL;
+ if ((new_len = strlen(str)) <= len)
+ return g_strdup(str);
+ if (g_utf8_validate(str, -1, NULL) == FALSE)
+ return g_strdup(str);
+
+ while (*p != '\0') {
+ mb_len = g_utf8_skip[*(guchar *)p];
+ if (mb_len == 0)
+ break;
+
+ new_len -= mb_len;
+ p += mb_len;
+
+ if (new_len <= len)
+ break;
+ }
+
+ return g_strconcat("...", p, NULL);
+}
+
+GList *uri_list_extract_filenames(const gchar *uri_list)
+{
+ GList *result = NULL;
+ const gchar *p, *q;
+ gchar *file;
+
+ p = uri_list;
+
+ while (p) {
+ if (*p != '#') {
+ while (g_ascii_isspace(*p)) p++;
+ if (!strncmp(p, "file:", 5)) {
+ p += 5;
+ while (*p == '/' && *(p + 1) == '/') p++;
+ q = p;
+ while (*q && *q != '\n' && *q != '\r') q++;
+
+ if (q > p) {
+ q--;
+ while (q > p && g_ascii_isspace(*q))
+ q--;
+ file = g_malloc(q - p + 2);
+ strncpy(file, p, q - p + 1);
+ file[q - p + 1] = '\0';
+ decode_uri(file, file);
+ result = g_list_append(result,file);
+ }
+ }
+ }
+ p = strchr(p, '\n');
+ if (p) p++;
+ }
+
+ return result;
+}
+
+#define HEX_TO_INT(val, hex) \
+{ \
+ gchar c = hex; \
+ \
+ if ('0' <= c && c <= '9') { \
+ val = c - '0'; \
+ } else if ('a' <= c && c <= 'f') { \
+ val = c - 'a' + 10; \
+ } else if ('A' <= c && c <= 'F') { \
+ val = c - 'A' + 10; \
+ } else { \
+ val = 0; \
+ } \
+}
+
+/* Converts two-digit hexadecimal to decimal. Used for unescaping escaped
+ * characters.
+ */
+static gint axtoi(const gchar *hex_str)
+{
+ gint hi, lo;
+
+ HEX_TO_INT(hi, hex_str[0]);
+ HEX_TO_INT(lo, hex_str[1]);
+
+ return (hi << 4) + lo;
+}
+
+gboolean is_uri_string(const gchar *str)
+{
+ return (g_ascii_strncasecmp(str, "http://", 7) == 0 ||
+ g_ascii_strncasecmp(str, "https://", 8) == 0 ||
+ g_ascii_strncasecmp(str, "ftp://", 6) == 0 ||
+ g_ascii_strncasecmp(str, "www.", 4) == 0);
+}
+
+gchar *get_uri_path(const gchar *uri)
+{
+ if (g_ascii_strncasecmp(uri, "http://", 7) == 0)
+ return (gchar *)(uri + 7);
+ else if (g_ascii_strncasecmp(uri, "https://", 8) == 0)
+ return (gchar *)(uri + 8);
+ else if (g_ascii_strncasecmp(uri, "ftp://", 6) == 0)
+ return (gchar *)(uri + 6);
+ else
+ return (gchar *)uri;
+}
+
+gint get_uri_len(const gchar *str)
+{
+ const gchar *p;
+
+ if (is_uri_string(str)) {
+ for (p = str; *p != '\0'; p++) {
+ if (!g_ascii_isgraph(*p) || strchr("()<>\"", *p))
+ break;
+ }
+ return p - str;
+ }
+
+ return 0;
+}
+
+/* Decodes URL-Encoded strings (i.e. strings in which spaces are replaced by
+ * plusses, and escape characters are used)
+ * Note: decoded_uri and encoded_uri can point the same location
+ */
+void decode_uri(gchar *decoded_uri, const gchar *encoded_uri)
+{
+ gchar *dec = decoded_uri;
+ const gchar *enc = encoded_uri;
+
+ while (*enc) {
+ if (*enc == '%') {
+ enc++;
+ if (isxdigit((guchar)enc[0]) &&
+ isxdigit((guchar)enc[1])) {
+ *dec = axtoi(enc);
+ dec++;
+ enc += 2;
+ }
+ } else {
+ if (*enc == '+')
+ *dec = ' ';
+ else
+ *dec = *enc;
+ dec++;
+ enc++;
+ }
+ }
+
+ *dec = '\0';
+}
+
+gchar *encode_uri(const gchar *filename)
+{
+ gchar *uri;
+
+ uri = g_filename_to_uri(filename, NULL, NULL);
+ if (!uri)
+ uri = g_strconcat("file://", filename, NULL);
+
+ return uri;
+}
+
+gint scan_mailto_url(const gchar *mailto, gchar **to, gchar **cc, gchar **bcc,
+ gchar **subject, gchar **body)
+{
+ gchar *tmp_mailto;
+ gchar *p;
+
+ Xstrdup_a(tmp_mailto, mailto, return -1);
+
+ if (!strncmp(tmp_mailto, "mailto:", 7))
+ tmp_mailto += 7;
+
+ p = strchr(tmp_mailto, '?');
+ if (p) {
+ *p = '\0';
+ p++;
+ }
+
+ if (to && !*to)
+ *to = g_strdup(tmp_mailto);
+
+ while (p) {
+ gchar *field, *value;
+
+ field = p;
+
+ p = strchr(p, '=');
+ if (!p) break;
+ *p = '\0';
+ p++;
+
+ value = p;
+
+ p = strchr(p, '&');
+ if (p) {
+ *p = '\0';
+ p++;
+ }
+
+ if (*value == '\0') continue;
+
+ if (cc && !*cc && !g_ascii_strcasecmp(field, "cc")) {
+ *cc = g_strdup(value);
+ } else if (bcc && !*bcc && !g_ascii_strcasecmp(field, "bcc")) {
+ *bcc = g_strdup(value);
+ } else if (subject && !*subject &&
+ !g_ascii_strcasecmp(field, "subject")) {
+ *subject = g_malloc(strlen(value) + 1);
+ decode_uri(*subject, value);
+ } else if (body && !*body &&
+ !g_ascii_strcasecmp(field, "body")) {
+ *body = g_malloc(strlen(value) + 1);
+ decode_uri(*body, value);
+ }
+ }
+
+ return 0;
+}
+
+const gchar *get_home_dir(void)
+{
+#ifdef G_OS_WIN32
+ static const gchar *home_dir = NULL;
+
+ if (!home_dir) {
+ home_dir = g_get_home_dir();
+ if (!home_dir)
+ home_dir = "C:\\Sylpheed";
+ }
+
+ return home_dir;
+#else
+ return g_get_home_dir();
+#endif
+}
+
+const gchar *get_rc_dir(void)
+{
+ static gchar *rc_dir = NULL;
+
+ if (!rc_dir)
+#ifdef G_OS_WIN32
+ rc_dir = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
+ "Application Data", G_DIR_SEPARATOR_S,
+ RC_DIR, NULL);
+#else
+ rc_dir = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
+ RC_DIR, NULL);
+#endif
+
+ return rc_dir;
+}
+
+const gchar *get_old_rc_dir(void)
+{
+ static gchar *old_rc_dir = NULL;
+
+ if (!old_rc_dir)
+ old_rc_dir = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
+ OLD_RC_DIR, NULL);
+
+ return old_rc_dir;
+}
+
+const gchar *get_mail_base_dir(void)
+{
+#ifdef G_OS_WIN32
+ static gchar *mail_base_dir = NULL;
+
+ if (!mail_base_dir)
+ mail_base_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ "Mailboxes", NULL);
+
+ return mail_base_dir;
+#else
+ return get_home_dir();
+#endif
+}
+
+const gchar *get_news_cache_dir(void)
+{
+ static gchar *news_cache_dir = NULL;
+
+ if (!news_cache_dir)
+ news_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ NEWS_CACHE_DIR, NULL);
+
+ return news_cache_dir;
+}
+
+const gchar *get_imap_cache_dir(void)
+{
+ static gchar *imap_cache_dir = NULL;
+
+ if (!imap_cache_dir)
+ imap_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ IMAP_CACHE_DIR, NULL);
+
+ return imap_cache_dir;
+}
+
+const gchar *get_mime_tmp_dir(void)
+{
+ static gchar *mime_tmp_dir = NULL;
+
+ if (!mime_tmp_dir)
+ mime_tmp_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ MIME_TMP_DIR, NULL);
+
+ return mime_tmp_dir;
+}
+
+const gchar *get_template_dir(void)
+{
+ static gchar *template_dir = NULL;
+
+ if (!template_dir)
+ template_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ TEMPLATE_DIR, NULL);
+
+ return template_dir;
+}
+
+const gchar *get_tmp_dir(void)
+{
+ static gchar *tmp_dir = NULL;
+
+ if (!tmp_dir)
+ tmp_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ TMP_DIR, NULL);
+
+ return tmp_dir;
+}
+
+gchar *get_tmp_file(void)
+{
+ gchar *tmp_file;
+ static guint32 id = 0;
+
+ tmp_file = g_strdup_printf("%s%ctmpfile.%08x",
+ get_tmp_dir(), G_DIR_SEPARATOR, id++);
+
+ return tmp_file;
+}
+
+const gchar *get_domain_name(void)
+{
+#ifdef G_OS_UNIX
+ static gchar *domain_name = NULL;
+
+ if (!domain_name) {
+ gchar buf[128] = "";
+ struct hostent *hp;
+
+ if (gethostname(buf, sizeof(buf)) < 0) {
+ perror("gethostname");
+ domain_name = "unknown";
+ } else {
+ buf[sizeof(buf) - 1] = '\0';
+ if ((hp = my_gethostbyname(buf)) == NULL) {
+ perror("gethostbyname");
+ domain_name = g_strdup(buf);
+ } else {
+ domain_name = g_strdup(hp->h_name);
+ }
+ }
+
+ debug_print("domain name = %s\n", domain_name);
+ }
+
+ return domain_name;
+#else
+ return "unknown";
+#endif
+}
+
+off_t get_file_size(const gchar *file)
+{
+ struct stat s;
+
+ if (g_stat(file, &s) < 0) {
+ FILE_OP_ERROR(file, "stat");
+ return -1;
+ }
+
+ return s.st_size;
+}
+
+off_t get_file_size_as_crlf(const gchar *file)
+{
+ FILE *fp;
+ off_t size = 0;
+ gchar buf[BUFFSIZE];
+
+ if ((fp = g_fopen(file, "rb")) == NULL) {
+ FILE_OP_ERROR(file, "fopen");
+ return -1;
+ }
+
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ strretchomp(buf);
+ size += strlen(buf) + 2;
+ }
+
+ if (ferror(fp)) {
+ FILE_OP_ERROR(file, "fgets");
+ size = -1;
+ }
+
+ fclose(fp);
+
+ return size;
+}
+
+off_t get_left_file_size(FILE *fp)
+{
+ glong pos;
+ glong end;
+ off_t size;
+
+ if ((pos = ftell(fp)) < 0) {
+ perror("ftell");
+ return -1;
+ }
+ if (fseek(fp, 0L, SEEK_END) < 0) {
+ perror("fseek");
+ return -1;
+ }
+ if ((end = ftell(fp)) < 0) {
+ perror("fseek");
+ return -1;
+ }
+ size = end - pos;
+ if (fseek(fp, pos, SEEK_SET) < 0) {
+ perror("fseek");
+ return -1;
+ }
+
+ return size;
+}
+
+gboolean file_exist(const gchar *file, gboolean allow_fifo)
+{
+ struct stat s;
+
+ if (file == NULL)
+ return FALSE;
+
+ if (g_stat(file, &s) < 0) {
+ if (ENOENT != errno) FILE_OP_ERROR(file, "stat");
+ return FALSE;
+ }
+
+ if (S_ISREG(s.st_mode) || (allow_fifo && S_ISFIFO(s.st_mode)))
+ return TRUE;
+
+ return FALSE;
+}
+
+gboolean is_dir_exist(const gchar *dir)
+{
+ if (dir == NULL)
+ return FALSE;
+
+ return g_file_test(dir, G_FILE_TEST_IS_DIR);
+}
+
+gboolean is_file_entry_exist(const gchar *file)
+{
+ if (file == NULL)
+ return FALSE;
+
+ return g_file_test(file, G_FILE_TEST_EXISTS);
+}
+
+gboolean dirent_is_regular_file(struct dirent *d)
+{
+#ifdef HAVE_DIRENT_D_TYPE
+ if (d->d_type == DT_REG)
+ return TRUE;
+ else if (d->d_type != DT_UNKNOWN)
+ return FALSE;
+#endif
+
+ return g_file_test(d->d_name, G_FILE_TEST_IS_REGULAR);
+}
+
+gboolean dirent_is_directory(struct dirent *d)
+{
+#ifdef HAVE_DIRENT_D_TYPE
+ if (d->d_type == DT_DIR)
+ return TRUE;
+ else if (d->d_type != DT_UNKNOWN)
+ return FALSE;
+#endif
+
+ return g_file_test(d->d_name, G_FILE_TEST_IS_DIR);
+}
+
+gint change_dir(const gchar *dir)
+{
+ gchar *prevdir = NULL;
+
+ if (debug_mode)
+ prevdir = g_get_current_dir();
+
+ if (g_chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ if (debug_mode) g_free(prevdir);
+ return -1;
+ } else if (debug_mode) {
+ gchar *cwd;
+
+ cwd = g_get_current_dir();
+ if (strcmp(prevdir, cwd) != 0)
+ g_print("current dir: %s\n", cwd);
+ g_free(cwd);
+ g_free(prevdir);
+ }
+
+ return 0;
+}
+
+gint make_dir(const gchar *dir)
+{
+ if (g_mkdir(dir, S_IRWXU) < 0) {
+ FILE_OP_ERROR(dir, "mkdir");
+ return -1;
+ }
+ if (g_chmod(dir, S_IRWXU) < 0)
+ FILE_OP_ERROR(dir, "chmod");
+
+ return 0;
+}
+
+gint make_dir_hier(const gchar *dir)
+{
+ gchar *parent_dir;
+ const gchar *p;
+
+ for (p = dir; (p = strchr(p, G_DIR_SEPARATOR)) != NULL; p++) {
+ parent_dir = g_strndup(dir, p - dir);
+ if (*parent_dir != '\0') {
+ if (!is_dir_exist(parent_dir)) {
+ if (make_dir(parent_dir) < 0) {
+ g_free(parent_dir);
+ return -1;
+ }
+ }
+ }
+ g_free(parent_dir);
+ }
+
+ if (!is_dir_exist(dir)) {
+ if (make_dir(dir) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+gint remove_all_files(const gchar *dir)
+{
+ GDir *dp;
+ const gchar *dir_name;
+ gchar *prev_dir;
+
+ prev_dir = g_get_current_dir();
+
+ if (g_chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
+ g_warning("failed to open directory: %s\n", dir);
+ g_free(prev_dir);
+ return -1;
+ }
+
+ while ((dir_name = g_dir_read_name(dp)) != NULL) {
+ if (g_unlink(dir_name) < 0)
+ FILE_OP_ERROR(dir_name, "unlink");
+ }
+
+ g_dir_close(dp);
+
+ if (g_chdir(prev_dir) < 0) {
+ FILE_OP_ERROR(prev_dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ g_free(prev_dir);
+
+ return 0;
+}
+
+gint remove_numbered_files(const gchar *dir, guint first, guint last)
+{
+ GDir *dp;
+ const gchar *dir_name;
+ gchar *prev_dir;
+ gint file_no;
+
+ prev_dir = g_get_current_dir();
+
+ if (g_chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
+ g_warning("failed to open directory: %s\n", dir);
+ g_free(prev_dir);
+ return -1;
+ }
+
+ while ((dir_name = g_dir_read_name(dp)) != NULL) {
+ file_no = to_number(dir_name);
+ if (file_no > 0 && first <= file_no && file_no <= last) {
+ if (is_dir_exist(dir_name))
+ continue;
+ if (g_unlink(dir_name) < 0)
+ FILE_OP_ERROR(dir_name, "unlink");
+ }
+ }
+
+ g_dir_close(dp);
+
+ if (g_chdir(prev_dir) < 0) {
+ FILE_OP_ERROR(prev_dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ g_free(prev_dir);
+
+ return 0;
+}
+
+gint remove_all_numbered_files(const gchar *dir)
+{
+ return remove_numbered_files(dir, 0, UINT_MAX);
+}
+
+gint remove_expired_files(const gchar *dir, guint hours)
+{
+ GDir *dp;
+ const gchar *dir_name;
+ struct stat s;
+ gchar *prev_dir;
+ gint file_no;
+ time_t mtime, now, expire_time;
+
+ prev_dir = g_get_current_dir();
+
+ if (g_chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
+ g_warning("failed to open directory: %s\n", dir);
+ g_free(prev_dir);
+ return -1;
+ }
+
+ now = time(NULL);
+ expire_time = hours * 60 * 60;
+
+ while ((dir_name = g_dir_read_name(dp)) != NULL) {
+ file_no = to_number(dir_name);
+ if (file_no > 0) {
+ if (g_stat(dir_name, &s) < 0) {
+ FILE_OP_ERROR(dir_name, "stat");
+ continue;
+ }
+ if (S_ISDIR(s.st_mode))
+ continue;
+ mtime = MAX(s.st_mtime, s.st_atime);
+ if (now - mtime > expire_time) {
+ if (g_unlink(dir_name) < 0)
+ FILE_OP_ERROR(dir_name, "unlink");
+ }
+ }
+ }
+
+ g_dir_close(dp);
+
+ if (g_chdir(prev_dir) < 0) {
+ FILE_OP_ERROR(prev_dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ g_free(prev_dir);
+
+ return 0;
+}
+
+static gint remove_dir_recursive_real(const gchar *dir)
+{
+ struct stat s;
+ GDir *dp;
+ const gchar *dir_name;
+ gchar *prev_dir;
+
+ if (g_stat(dir, &s) < 0) {
+ FILE_OP_ERROR(dir, "stat");
+ if (ENOENT == errno) return 0;
+ return -1;
+ }
+
+ if (!S_ISDIR(s.st_mode)) {
+ if (g_unlink(dir) < 0) {
+ FILE_OP_ERROR(dir, "unlink");
+ return -1;
+ }
+
+ return 0;
+ }
+
+ prev_dir = g_get_current_dir();
+ /* g_print("prev_dir = %s\n", prev_dir); */
+
+ if (g_chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
+ g_warning("failed to open directory: %s\n", dir);
+ g_chdir(prev_dir);
+ g_free(prev_dir);
+ return -1;
+ }
+
+ /* remove all files in the directory */
+ while ((dir_name = g_dir_read_name(dp)) != NULL) {
+ /* g_print("removing %s\n", dir_name); */
+
+ if (is_dir_exist(dir_name)) {
+ if (remove_dir_recursive_real(dir_name) < 0) {
+ g_warning("can't remove directory\n");
+ return -1;
+ }
+ } else {
+ if (g_unlink(dir_name) < 0)
+ FILE_OP_ERROR(dir_name, "unlink");
+ }
+ }
+
+ g_dir_close(dp);
+
+ if (g_chdir(prev_dir) < 0) {
+ FILE_OP_ERROR(prev_dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ g_free(prev_dir);
+
+ if (g_rmdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "rmdir");
+ return -1;
+ }
+
+ return 0;
+}
+
+gint remove_dir_recursive(const gchar *dir)
+{
+ gchar *cur_dir;
+ gint ret;
+
+ cur_dir = g_get_current_dir();
+
+ if (g_chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ ret = -1;
+ goto leave;
+ }
+ if (g_chdir("..") < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ ret = -1;
+ goto leave;
+ }
+
+ ret = remove_dir_recursive_real(dir);
+
+leave:
+ if (is_dir_exist(cur_dir)) {
+ if (g_chdir(cur_dir) < 0) {
+ FILE_OP_ERROR(cur_dir, "chdir");
+ }
+ }
+
+ g_free(cur_dir);
+
+ return ret;
+}
+
+gint rename_force(const gchar *oldpath, const gchar *newpath)
+{
+#ifndef G_OS_UNIX
+ if (!is_file_entry_exist(oldpath)) {
+ errno = ENOENT;
+ return -1;
+ }
+ if (is_file_exist(newpath)) {
+ if (g_unlink(newpath) < 0)
+ FILE_OP_ERROR(newpath, "unlink");
+ }
+#endif
+ return g_rename(oldpath, newpath);
+}
+
+gint copy_file(const gchar *src, const gchar *dest, gboolean keep_backup)
+{
+ FILE *src_fp, *dest_fp;
+ gint n_read;
+ gchar buf[BUFSIZ];
+ gchar *dest_bak = NULL;
+ gboolean err = FALSE;
+
+ if ((src_fp = g_fopen(src, "rb")) == NULL) {
+ FILE_OP_ERROR(src, "fopen");
+ return -1;
+ }
+ if (is_file_exist(dest)) {
+ dest_bak = g_strconcat(dest, ".bak", NULL);
+ if (rename_force(dest, dest_bak) < 0) {
+ FILE_OP_ERROR(dest, "rename");
+ fclose(src_fp);
+ g_free(dest_bak);
+ return -1;
+ }
+ }
+
+ if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
+ FILE_OP_ERROR(dest, "fopen");
+ fclose(src_fp);
+ if (dest_bak) {
+ if (rename_force(dest_bak, dest) < 0)
+ FILE_OP_ERROR(dest_bak, "rename");
+ g_free(dest_bak);
+ }
+ return -1;
+ }
+
+ if (change_file_mode_rw(dest_fp, dest) < 0) {
+ FILE_OP_ERROR(dest, "chmod");
+ g_warning(_("can't change file mode\n"));
+ }
+
+ while ((n_read = fread(buf, sizeof(gchar), sizeof(buf), src_fp)) > 0) {
+ if (n_read < sizeof(buf) && ferror(src_fp))
+ break;
+ if (fwrite(buf, n_read, 1, dest_fp) < 1) {
+ g_warning(_("writing to %s failed.\n"), dest);
+ fclose(dest_fp);
+ fclose(src_fp);
+ g_unlink(dest);
+ if (dest_bak) {
+ if (rename_force(dest_bak, dest) < 0)
+ FILE_OP_ERROR(dest_bak, "rename");
+ g_free(dest_bak);
+ }
+ return -1;
+ }
+ }
+
+ if (ferror(src_fp)) {
+ FILE_OP_ERROR(src, "fread");
+ err = TRUE;
+ }
+ fclose(src_fp);
+ if (fclose(dest_fp) == EOF) {
+ FILE_OP_ERROR(dest, "fclose");
+ err = TRUE;
+ }
+
+ if (err) {
+ g_unlink(dest);
+ if (dest_bak) {
+ if (rename_force(dest_bak, dest) < 0)
+ FILE_OP_ERROR(dest_bak, "rename");
+ g_free(dest_bak);
+ }
+ return -1;
+ }
+
+ if (keep_backup == FALSE && dest_bak)
+ g_unlink(dest_bak);
+
+ g_free(dest_bak);
+
+ return 0;
+}
+
+gint copy_dir(const gchar *src, const gchar *dest)
+{
+ GDir *dir;
+ const gchar *dir_name;
+ gchar *src_file;
+ gchar *dest_file;
+
+ if ((dir = g_dir_open(src, 0, NULL)) == NULL) {
+ g_warning("failed to open directory: %s\n", src);
+ return -1;
+ }
+
+ if (make_dir_hier(dest) < 0) {
+ g_dir_close(dir);
+ return -1;
+ }
+
+ while ((dir_name = g_dir_read_name(dir)) != NULL) {
+ src_file = g_strconcat(src, G_DIR_SEPARATOR_S, dir_name, NULL);
+ dest_file = g_strconcat(dest, G_DIR_SEPARATOR_S, dir_name,
+ NULL);
+ if (is_file_exist(src_file))
+ copy_file(src_file, dest_file, FALSE);
+ g_free(dest_file);
+ g_free(src_file);
+ }
+
+ g_dir_close(dir);
+
+ return 0;
+}
+
+gint move_file(const gchar *src, const gchar *dest, gboolean overwrite)
+{
+ if (overwrite == FALSE && is_file_exist(dest)) {
+ g_warning("move_file(): file %s already exists.", dest);
+ return -1;
+ }
+
+ if (rename_force(src, dest) == 0) return 0;
+
+ if (EXDEV != errno) {
+ FILE_OP_ERROR(src, "rename");
+ return -1;
+ }
+
+ if (copy_file(src, dest, FALSE) < 0) return -1;
+
+ g_unlink(src);
+
+ return 0;
+}
+
+gint copy_file_part(FILE *fp, off_t offset, size_t length, const gchar *dest)
+{
+ FILE *dest_fp;
+ gint n_read;
+ gint bytes_left, to_read;
+ gchar buf[BUFSIZ];
+ gboolean err = FALSE;
+
+ if (fseek(fp, offset, SEEK_SET) < 0) {
+ perror("fseek");
+ return -1;
+ }
+
+ if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
+ FILE_OP_ERROR(dest, "fopen");
+ return -1;
+ }
+
+ if (change_file_mode_rw(dest_fp, dest) < 0) {
+ FILE_OP_ERROR(dest, "chmod");
+ g_warning("can't change file mode\n");
+ }
+
+ bytes_left = length;
+ to_read = MIN(bytes_left, sizeof(buf));
+
+ while ((n_read = fread(buf, sizeof(gchar), to_read, fp)) > 0) {
+ if (n_read < to_read && ferror(fp))
+ break;
+ if (fwrite(buf, n_read, 1, dest_fp) < 1) {
+ g_warning(_("writing to %s failed.\n"), dest);
+ fclose(dest_fp);
+ g_unlink(dest);
+ return -1;
+ }
+ bytes_left -= n_read;
+ if (bytes_left == 0)
+ break;
+ to_read = MIN(bytes_left, sizeof(buf));
+ }
+
+ if (ferror(fp)) {
+ perror("fread");
+ err = TRUE;
+ }
+ if (fclose(dest_fp) == EOF) {
+ FILE_OP_ERROR(dest, "fclose");
+ err = TRUE;
+ }
+
+ if (err) {
+ g_unlink(dest);
+ return -1;
+ }
+
+ return 0;
+}
+
+/* convert line endings into CRLF. If the last line doesn't end with
+ * linebreak, add it.
+ */
+gchar *canonicalize_str(const gchar *str)
+{
+ const gchar *p;
+ guint new_len = 0;
+ gchar *out, *outp;
+
+ for (p = str; *p != '\0'; ++p) {
+ if (*p != '\r') {
+ ++new_len;
+ if (*p == '\n')
+ ++new_len;
+ }
+ }
+ if (p == str || *(p - 1) != '\n')
+ new_len += 2;
+
+ out = outp = g_malloc(new_len + 1);
+ for (p = str; *p != '\0'; ++p) {
+ if (*p != '\r') {
+ if (*p == '\n')
+ *outp++ = '\r';
+ *outp++ = *p;
+ }
+ }
+ if (p == str || *(p - 1) != '\n') {
+ *outp++ = '\r';
+ *outp++ = '\n';
+ }
+ *outp = '\0';
+
+ return out;
+}
+
+gint canonicalize_file(const gchar *src, const gchar *dest)
+{
+ FILE *src_fp, *dest_fp;
+ gchar buf[BUFFSIZE];
+ gint len;
+ gboolean err = FALSE;
+ gboolean last_linebreak = FALSE;
+
+ if ((src_fp = g_fopen(src, "rb")) == NULL) {
+ FILE_OP_ERROR(src, "fopen");
+ return -1;
+ }
+
+ if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
+ FILE_OP_ERROR(dest, "fopen");
+ fclose(src_fp);
+ return -1;
+ }
+
+ if (change_file_mode_rw(dest_fp, dest) < 0) {
+ FILE_OP_ERROR(dest, "chmod");
+ g_warning("can't change file mode\n");
+ }
+
+ while (fgets(buf, sizeof(buf), src_fp) != NULL) {
+ gint r = 0;
+
+ len = strlen(buf);
+ if (len == 0) break;
+ last_linebreak = FALSE;
+
+ if (buf[len - 1] != '\n') {
+ last_linebreak = TRUE;
+ r = fputs(buf, dest_fp);
+ } else if (len > 1 && buf[len - 1] == '\n' && buf[len - 2] == '\r') {
+ r = fputs(buf, dest_fp);
+ } else {
+ if (len > 1) {
+ r = fwrite(buf, len - 1, 1, dest_fp);
+ if (r != 1)
+ r = EOF;
+ }
+ if (r != EOF)
+ r = fputs("\r\n", dest_fp);
+ }
+
+ if (r == EOF) {
+ g_warning("writing to %s failed.\n", dest);
+ fclose(dest_fp);
+ fclose(src_fp);
+ g_unlink(dest);
+ return -1;
+ }
+ }
+
+ if (last_linebreak == TRUE) {
+ if (fputs("\r\n", dest_fp) == EOF)
+ err = TRUE;
+ }
+
+ if (ferror(src_fp)) {
+ FILE_OP_ERROR(src, "fgets");
+ err = TRUE;
+ }
+ fclose(src_fp);
+ if (fclose(dest_fp) == EOF) {
+ FILE_OP_ERROR(dest, "fclose");
+ err = TRUE;
+ }
+
+ if (err) {
+ g_unlink(dest);
+ return -1;
+ }
+
+ return 0;
+}
+
+gint canonicalize_file_replace(const gchar *file)
+{
+ gchar *tmp_file;
+
+ tmp_file = get_tmp_file();
+
+ if (canonicalize_file(file, tmp_file) < 0) {
+ g_free(tmp_file);
+ return -1;
+ }
+
+ if (move_file(tmp_file, file, TRUE) < 0) {
+ g_warning("can't replace %s .\n", file);
+ g_unlink(tmp_file);
+ g_free(tmp_file);
+ return -1;
+ }
+
+ g_free(tmp_file);
+ return 0;
+}
+
+gint uncanonicalize_file(const gchar *src, const gchar *dest)
+{
+ FILE *src_fp, *dest_fp;
+ gchar buf[BUFFSIZE];
+ gboolean err = FALSE;
+
+ if ((src_fp = g_fopen(src, "rb")) == NULL) {
+ FILE_OP_ERROR(src, "fopen");
+ return -1;
+ }
+
+ if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
+ FILE_OP_ERROR(dest, "fopen");
+ fclose(src_fp);
+ return -1;
+ }
+
+ if (change_file_mode_rw(dest_fp, dest) < 0) {
+ FILE_OP_ERROR(dest, "chmod");
+ g_warning("can't change file mode\n");
+ }
+
+ while (fgets(buf, sizeof(buf), src_fp) != NULL) {
+ strcrchomp(buf);
+ if (fputs(buf, dest_fp) == EOF) {
+ g_warning("writing to %s failed.\n", dest);
+ fclose(dest_fp);
+ fclose(src_fp);
+ g_unlink(dest);
+ return -1;
+ }
+ }
+
+ if (ferror(src_fp)) {
+ FILE_OP_ERROR(src, "fgets");
+ err = TRUE;
+ }
+ fclose(src_fp);
+ if (fclose(dest_fp) == EOF) {
+ FILE_OP_ERROR(dest, "fclose");
+ err = TRUE;
+ }
+
+ if (err) {
+ g_unlink(dest);
+ return -1;
+ }
+
+ return 0;
+}
+
+gint uncanonicalize_file_replace(const gchar *file)
+{
+ gchar *tmp_file;
+
+ tmp_file = get_tmp_file();
+
+ if (uncanonicalize_file(file, tmp_file) < 0) {
+ g_free(tmp_file);
+ return -1;
+ }
+
+ if (move_file(tmp_file, file, TRUE) < 0) {
+ g_warning("can't replace %s .\n", file);
+ g_unlink(tmp_file);
+ g_free(tmp_file);
+ return -1;
+ }
+
+ g_free(tmp_file);
+ return 0;
+}
+
+gchar *normalize_newlines(const gchar *str)
+{
+ const gchar *p = str;
+ gchar *out, *outp;
+
+ out = outp = g_malloc(strlen(str) + 1);
+ for (p = str; *p != '\0'; ++p) {
+ if (*p == '\r') {
+ if (*(p + 1) != '\n')
+ *outp++ = '\n';
+ } else
+ *outp++ = *p;
+ }
+
+ *outp = '\0';
+
+ return out;
+}
+
+gchar *get_outgoing_rfc2822_str(FILE *fp)
+{
+ gchar buf[BUFFSIZE];
+ GString *str;
+ gchar *ret;
+
+ str = g_string_new(NULL);
+
+ /* output header part */
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ strretchomp(buf);
+ if (!g_ascii_strncasecmp(buf, "Bcc:", 4)) {
+ gint next;
+
+ for (;;) {
+ next = fgetc(fp);
+ if (next == EOF)
+ break;
+ else if (next != ' ' && next != '\t') {
+ ungetc(next, fp);
+ break;
+ }
+ if (fgets(buf, sizeof(buf), fp) == NULL)
+ break;
+ }
+#if 0
+ } else if (!g_ascii_strncasecmp(buf, "Date:", 5)) {
+ get_rfc822_date(buf, sizeof(buf));
+ g_string_append_printf(str, "Date: %s\r\n", buf);
+#endif
+ } else {
+ g_string_append(str, buf);
+ g_string_append(str, "\r\n");
+ if (buf[0] == '\0')
+ break;
+ }
+ }
+
+ /* output body part */
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ strretchomp(buf);
+ if (buf[0] == '.')
+ g_string_append_c(str, '.');
+ g_string_append(str, buf);
+ g_string_append(str, "\r\n");
+ }
+
+ ret = str->str;
+ g_string_free(str, FALSE);
+
+ return ret;
+}
+
+/*
+ * Create a new boundary in a way that it is very unlikely that this
+ * will occur in the following text. It would be easy to ensure
+ * uniqueness if everything is either quoted-printable or base64
+ * encoded (note that conversion is allowed), but because MIME bodies
+ * may be nested, it may happen that the same boundary has already
+ * been used. We avoid scanning the message for conflicts and hope the
+ * best.
+ *
+ * boundary := 0*69<bchars> bcharsnospace
+ * bchars := bcharsnospace / " "
+ * bcharsnospace := DIGIT / ALPHA / "'" / "(" / ")" /
+ * "+" / "_" / "," / "-" / "." /
+ * "/" / ":" / "=" / "?"
+ *
+ * some special characters removed because of buggy MTAs
+ */
+
+gchar *generate_mime_boundary(const gchar *prefix)
+{
+ static gchar tbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "1234567890+_./=";
+ gchar buf_uniq[17];
+ gchar buf_date[64];
+ gint i;
+
+ for (i = 0; i < sizeof(buf_uniq) - 1; i++)
+ buf_uniq[i] = tbl[g_random_int_range(0, sizeof(tbl) - 1)];
+ buf_uniq[i] = '\0';
+
+ get_rfc822_date(buf_date, sizeof(buf_date));
+ subst_char(buf_date, ' ', '_');
+ subst_char(buf_date, ',', '_');
+ subst_char(buf_date, ':', '_');
+
+ return g_strdup_printf("%s=_%s_%s", prefix ? prefix : "Multipart",
+ buf_date, buf_uniq);
+}
+
+gint change_file_mode_rw(FILE *fp, const gchar *file)
+{
+#if HAVE_FCHMOD
+ return fchmod(fileno(fp), S_IRUSR|S_IWUSR);
+#else
+ return g_chmod(file, S_IRUSR|S_IWUSR);
+#endif
+}
+
+FILE *my_tmpfile(void)
+{
+#if HAVE_MKSTEMP
+ const gchar suffix[] = ".XXXXXX";
+ const gchar *tmpdir;
+ guint tmplen;
+ const gchar *progname;
+ guint proglen;
+ gchar *fname;
+ gint fd;
+ FILE *fp;
+
+ tmpdir = get_tmp_dir();
+ tmplen = strlen(tmpdir);
+ progname = g_get_prgname();
+ proglen = strlen(progname);
+ Xalloca(fname, tmplen + 1 + proglen + sizeof(suffix),
+ return tmpfile());
+
+ memcpy(fname, tmpdir, tmplen);
+ fname[tmplen] = G_DIR_SEPARATOR;
+ memcpy(fname + tmplen + 1, progname, proglen);
+ memcpy(fname + tmplen + 1 + proglen, suffix, sizeof(suffix));
+
+ fd = mkstemp(fname);
+ if (fd < 0)
+ return tmpfile();
+
+ g_unlink(fname);
+
+ fp = fdopen(fd, "w+b");
+ if (!fp)
+ close(fd);
+ else
+ return fp;
+#endif /* HAVE_MKSTEMP */
+
+ return tmpfile();
+}
+
+FILE *str_open_as_stream(const gchar *str)
+{
+ FILE *fp;
+ size_t len;
+
+ g_return_val_if_fail(str != NULL, NULL);
+
+ fp = my_tmpfile();
+ if (!fp) {
+ FILE_OP_ERROR("str_open_as_stream", "my_tmpfile");
+ return NULL;
+ }
+
+ len = strlen(str);
+ if (len == 0) return fp;
+
+ if (fwrite(str, len, 1, fp) != 1) {
+ FILE_OP_ERROR("str_open_as_stream", "fwrite");
+ fclose(fp);
+ return NULL;
+ }
+
+ rewind(fp);
+ return fp;
+}
+
+gint str_write_to_file(const gchar *str, const gchar *file)
+{
+ FILE *fp;
+ size_t len;
+
+ g_return_val_if_fail(str != NULL, -1);
+ g_return_val_if_fail(file != NULL, -1);
+
+ if ((fp = g_fopen(file, "wb")) == NULL) {
+ FILE_OP_ERROR(file, "fopen");
+ return -1;
+ }
+
+ len = strlen(str);
+ if (len == 0) {
+ fclose(fp);
+ return 0;
+ }
+
+ if (fwrite(str, len, 1, fp) != 1) {
+ FILE_OP_ERROR(file, "fwrite");
+ fclose(fp);
+ g_unlink(file);
+ return -1;
+ }
+
+ if (fclose(fp) == EOF) {
+ FILE_OP_ERROR(file, "fclose");
+ g_unlink(file);
+ return -1;
+ }
+
+ return 0;
+}
+
+gchar *file_read_to_str(const gchar *file)
+{
+ FILE *fp;
+ gchar *str;
+
+ g_return_val_if_fail(file != NULL, NULL);
+
+ if ((fp = g_fopen(file, "rb")) == NULL) {
+ FILE_OP_ERROR(file, "fopen");
+ return NULL;
+ }
+
+ str = file_read_stream_to_str(fp);
+
+ fclose(fp);
+
+ return str;
+}
+
+gchar *file_read_stream_to_str(FILE *fp)
+{
+ GByteArray *array;
+ guchar buf[BUFSIZ];
+ gint n_read;
+ gchar *str;
+
+ g_return_val_if_fail(fp != NULL, NULL);
+
+ array = g_byte_array_new();
+
+ while ((n_read = fread(buf, sizeof(gchar), sizeof(buf), fp)) > 0) {
+ if (n_read < sizeof(buf) && ferror(fp))
+ break;
+ g_byte_array_append(array, buf, n_read);
+ }
+
+ if (ferror(fp)) {
+ FILE_OP_ERROR("file stream", "fread");
+ g_byte_array_free(array, TRUE);
+ return NULL;
+ }
+
+ buf[0] = '\0';
+ g_byte_array_append(array, buf, 1);
+ str = (gchar *)array->data;
+ g_byte_array_free(array, FALSE);
+
+ return str;
+}
+
+gint execute_async(gchar *const argv[])
+{
+ g_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
+
+ if (g_spawn_async(NULL, (gchar **)argv, NULL, G_SPAWN_SEARCH_PATH,
+ NULL, NULL, NULL, FALSE) == FALSE) {
+ g_warning("Can't execute command: %s\n", argv[0]);
+ return -1;
+ }
+
+ return 0;
+}
+
+gint execute_sync(gchar *const argv[])
+{
+ gint status;
+
+ g_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
+
+ if (g_spawn_sync(NULL, (gchar **)argv, NULL, G_SPAWN_SEARCH_PATH,
+ NULL, NULL, NULL, NULL, &status, NULL) == FALSE) {
+ g_warning("Can't execute command: %s\n", argv[0]);
+ return -1;
+ }
+
+#ifdef G_OS_UNIX
+ if (WIFEXITED(status))
+ return WEXITSTATUS(status);
+ else
+ return -1;
+#else
+ return status;
+#endif
+}
+
+gint execute_command_line(const gchar *cmdline, gboolean async)
+{
+ gchar **argv;
+ gint ret;
+
+ debug_print("execute_command_line(): executing: %s\n", cmdline);
+
+ argv = strsplit_with_quote(cmdline, " ", 0);
+
+ if (async)
+ ret = execute_async(argv);
+ else
+ ret = execute_sync(argv);
+
+ g_strfreev(argv);
+
+ return ret;
+}
+
+gchar *get_command_output(const gchar *cmdline)
+{
+ gchar *child_stdout;
+ gint status;
+
+ g_return_val_if_fail(cmdline != NULL, NULL);
+
+ debug_print("get_command_output(): executing: %s\n", cmdline);
+
+ if (g_spawn_command_line_sync(cmdline, &child_stdout, NULL, &status,
+ NULL) == FALSE) {
+ g_warning("Can't execute command: %s\n", cmdline);
+ return NULL;
+ }
+
+ return child_stdout;
+}
+
+gint open_uri(const gchar *uri, const gchar *cmdline)
+{
+ gchar buf[BUFFSIZE];
+ gchar *p;
+
+ g_return_val_if_fail(uri != NULL, -1);
+
+ if (cmdline &&
+ (p = strchr(cmdline, '%')) && *(p + 1) == 's' &&
+ !strchr(p + 2, '%'))
+ g_snprintf(buf, sizeof(buf), cmdline, uri);
+ else {
+ if (cmdline)
+ g_warning("Open URI command line is invalid "
+ "(there must be only one '%%s'): %s",
+ cmdline);
+ g_snprintf(buf, sizeof(buf), DEFAULT_BROWSER_CMD, uri);
+ }
+
+ execute_command_line(buf, TRUE);
+
+ return 0;
+}
+
+time_t remote_tzoffset_sec(const gchar *zone)
+{
+ static gchar ustzstr[] = "PSTPDTMSTMDTCSTCDTESTEDT";
+ gchar zone3[4];
+ gchar *p;
+ gchar c;
+ gint iustz;
+ gint offset;
+ time_t remoteoffset;
+
+ strncpy(zone3, zone, 3);
+ zone3[3] = '\0';
+ remoteoffset = 0;
+
+ if (sscanf(zone, "%c%d", &c, &offset) == 2 &&
+ (c == '+' || c == '-')) {
+ remoteoffset = ((offset / 100) * 60 + (offset % 100)) * 60;
+ if (c == '-')
+ remoteoffset = -remoteoffset;
+ } else if (!strncmp(zone, "UT" , 2) ||
+ !strncmp(zone, "GMT", 2)) {
+ remoteoffset = 0;
+ } else if (strlen(zone3) == 3) {
+ for (p = ustzstr; *p != '\0'; p += 3) {
+ if (!g_ascii_strncasecmp(p, zone3, 3)) {
+ iustz = ((gint)(p - ustzstr) / 3 + 1) / 2 - 8;
+ remoteoffset = iustz * 3600;
+ break;
+ }
+ }
+ if (*p == '\0')
+ return -1;
+ } else if (strlen(zone3) == 1) {
+ switch (zone[0]) {
+ case 'Z': remoteoffset = 0; break;
+ case 'A': remoteoffset = -1; break;
+ case 'B': remoteoffset = -2; break;
+ case 'C': remoteoffset = -3; break;
+ case 'D': remoteoffset = -4; break;
+ case 'E': remoteoffset = -5; break;
+ case 'F': remoteoffset = -6; break;
+ case 'G': remoteoffset = -7; break;
+ case 'H': remoteoffset = -8; break;
+ case 'I': remoteoffset = -9; break;
+ case 'K': remoteoffset = -10; break; /* J is not used */
+ case 'L': remoteoffset = -11; break;
+ case 'M': remoteoffset = -12; break;
+ case 'N': remoteoffset = 1; break;
+ case 'O': remoteoffset = 2; break;
+ case 'P': remoteoffset = 3; break;
+ case 'Q': remoteoffset = 4; break;
+ case 'R': remoteoffset = 5; break;
+ case 'S': remoteoffset = 6; break;
+ case 'T': remoteoffset = 7; break;
+ case 'U': remoteoffset = 8; break;
+ case 'V': remoteoffset = 9; break;
+ case 'W': remoteoffset = 10; break;
+ case 'X': remoteoffset = 11; break;
+ case 'Y': remoteoffset = 12; break;
+ default: remoteoffset = 0; break;
+ }
+ remoteoffset = remoteoffset * 3600;
+ } else
+ return -1;
+
+ return remoteoffset;
+}
+
+time_t tzoffset_sec(time_t *now)
+{
+ struct tm gmt, *lt;
+ gint off;
+
+ gmt = *gmtime(now);
+ lt = localtime(now);
+
+ off = (lt->tm_hour - gmt.tm_hour) * 60 + lt->tm_min - gmt.tm_min;
+
+ if (lt->tm_year < gmt.tm_year)
+ off -= 24 * 60;
+ else if (lt->tm_year > gmt.tm_year)
+ off += 24 * 60;
+ else if (lt->tm_yday < gmt.tm_yday)
+ off -= 24 * 60;
+ else if (lt->tm_yday > gmt.tm_yday)
+ off += 24 * 60;
+
+ if (off >= 24 * 60) /* should be impossible */
+ off = 23 * 60 + 59; /* if not, insert silly value */
+ if (off <= -24 * 60)
+ off = -(23 * 60 + 59);
+
+ return off * 60;
+}
+
+/* calculate timezone offset */
+gchar *tzoffset(time_t *now)
+{
+ static gchar offset_string[6];
+ struct tm gmt, *lt;
+ gint off;
+ gchar sign = '+';
+
+ gmt = *gmtime(now);
+ lt = localtime(now);
+
+ off = (lt->tm_hour - gmt.tm_hour) * 60 + lt->tm_min - gmt.tm_min;
+
+ if (lt->tm_year < gmt.tm_year)
+ off -= 24 * 60;
+ else if (lt->tm_year > gmt.tm_year)
+ off += 24 * 60;
+ else if (lt->tm_yday < gmt.tm_yday)
+ off -= 24 * 60;
+ else if (lt->tm_yday > gmt.tm_yday)
+ off += 24 * 60;
+
+ if (off < 0) {
+ sign = '-';
+ off = -off;
+ }
+
+ if (off >= 24 * 60) /* should be impossible */
+ off = 23 * 60 + 59; /* if not, insert silly value */
+
+ sprintf(offset_string, "%c%02d%02d", sign, off / 60, off % 60);
+
+ return offset_string;
+}
+
+void get_rfc822_date(gchar *buf, gint len)
+{
+ struct tm *lt;
+ time_t t;
+ gchar day[4], mon[4];
+ gint dd, hh, mm, ss, yyyy;
+
+ t = time(NULL);
+ lt = localtime(&t);
+
+ sscanf(asctime(lt), "%3s %3s %d %d:%d:%d %d\n",
+ day, mon, &dd, &hh, &mm, &ss, &yyyy);
+ g_snprintf(buf, len, "%s, %d %s %d %02d:%02d:%02d %s",
+ day, dd, mon, yyyy, hh, mm, ss, tzoffset(&t));
+}
+
+/* just a wrapper to suppress the warning of gcc about %c */
+size_t my_strftime(gchar *s, size_t max, const gchar *format,
+ const struct tm *tm)
+{
+ return strftime(s, max, format, tm);
+}
+
+static FILE *log_fp = NULL;
+
+void set_log_file(const gchar *filename)
+{
+ if (log_fp) return;
+ log_fp = g_fopen(filename, "wb");
+ if (!log_fp)
+ FILE_OP_ERROR(filename, "fopen");
+}
+
+void close_log_file(void)
+{
+ if (log_fp) {
+ fclose(log_fp);
+ log_fp = NULL;
+ }
+}
+
+static guint log_verbosity_count = 0;
+
+void set_log_verbosity(gboolean verbose)
+{
+ if (verbose)
+ log_verbosity_count++;
+ else if (log_verbosity_count > 0)
+ log_verbosity_count--;
+}
+
+gboolean get_debug_mode(void)
+{
+ return debug_mode;
+}
+
+void set_debug_mode(gboolean enable)
+{
+ debug_mode = enable;
+}
+
+static void log_dummy_func(const gchar *str)
+{
+}
+
+static LogFunc log_print_ui_func = log_dummy_func;
+static LogFunc log_message_ui_func = log_dummy_func;
+static LogFunc log_warning_ui_func = log_dummy_func;
+static LogFunc log_error_ui_func = log_dummy_func;
+
+static LogFunc log_show_status_func = log_dummy_func;
+
+void set_log_ui_func(LogFunc print_func, LogFunc message_func,
+ LogFunc warning_func, LogFunc error_func)
+{
+ log_print_ui_func = print_func;
+ log_message_ui_func = message_func;
+ log_warning_ui_func = warning_func;
+ log_error_ui_func = error_func;
+}
+
+void set_log_show_status_func(LogFunc status_func)
+{
+ log_show_status_func = status_func;
+}
+
+void debug_print(const gchar *format, ...)
+{
+ va_list args;
+ gchar buf[BUFFSIZE];
+
+ if (!debug_mode) return;
+
+ va_start(args, format);
+ g_vsnprintf(buf, sizeof(buf), format, args);
+ va_end(args);
+
+ g_print("%s", buf);
+}
+
+#define TIME_LEN 11
+
+void log_print(const gchar *format, ...)
+{
+ va_list args;
+ gchar buf[BUFFSIZE + TIME_LEN];
+ time_t t;
+
+ time(&t);
+ strftime(buf, TIME_LEN + 1, "[%H:%M:%S] ", localtime(&t));
+
+ va_start(args, format);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
+ va_end(args);
+
+ if (debug_mode) fputs(buf, stdout);
+ log_print_ui_func(buf);
+ if (log_fp) {
+ fputs(buf, log_fp);
+ fflush(log_fp);
+ }
+ if (log_verbosity_count)
+ log_show_status_func(buf + TIME_LEN);
+}
+
+void log_message(const gchar *format, ...)
+{
+ va_list args;
+ gchar buf[BUFFSIZE + TIME_LEN];
+ time_t t;
+
+ time(&t);
+ strftime(buf, TIME_LEN + 1, "[%H:%M:%S] ", localtime(&t));
+
+ va_start(args, format);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
+ va_end(args);
+
+ if (debug_mode) g_message("%s", buf + TIME_LEN);
+ log_message_ui_func(buf + TIME_LEN);
+ if (log_fp) {
+ fwrite(buf, TIME_LEN, 1, log_fp);
+ fputs("* message: ", log_fp);
+ fputs(buf + TIME_LEN, log_fp);
+ fflush(log_fp);
+ }
+ log_show_status_func(buf + TIME_LEN);
+}
+
+void log_warning(const gchar *format, ...)
+{
+ va_list args;
+ gchar buf[BUFFSIZE + TIME_LEN];
+ time_t t;
+
+ time(&t);
+ strftime(buf, TIME_LEN + 1, "[%H:%M:%S] ", localtime(&t));
+
+ va_start(args, format);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
+ va_end(args);
+
+ g_warning("%s", buf);
+ log_warning_ui_func(buf + TIME_LEN);
+ if (log_fp) {
+ fwrite(buf, TIME_LEN, 1, log_fp);
+ fputs("** warning: ", log_fp);
+ fputs(buf + TIME_LEN, log_fp);
+ fflush(log_fp);
+ }
+}
+
+void log_error(const gchar *format, ...)
+{
+ va_list args;
+ gchar buf[BUFFSIZE + TIME_LEN];
+ time_t t;
+
+ time(&t);
+ strftime(buf, TIME_LEN + 1, "[%H:%M:%S] ", localtime(&t));
+
+ va_start(args, format);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
+ va_end(args);
+
+ g_warning("%s", buf);
+ log_error_ui_func(buf + TIME_LEN);
+ if (log_fp) {
+ fwrite(buf, TIME_LEN, 1, log_fp);
+ fputs("*** error: ", log_fp);
+ fputs(buf + TIME_LEN, log_fp);
+ fflush(log_fp);
+ }
+}
diff --git a/libsylph/utils.h b/libsylph/utils.h
new file mode 100644
index 00000000..fbda26a3
--- /dev/null
+++ b/libsylph/utils.h
@@ -0,0 +1,493 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __UTILS_H__
+#define __UTILS_H__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <time.h>
+#if HAVE_ALLOCA_H
+# include <alloca.h>
+#endif
+#if HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
+/* Wrappers for C library function that take pathname arguments. */
+#if GLIB_CHECK_VERSION(2, 6, 0)
+# include <glib/gstdio.h>
+#else
+
+#define g_open open
+#define g_rename rename
+#define g_mkdir mkdir
+#define g_stat stat
+#define g_lstat lstat
+#define g_unlink unlink
+#define g_remove remove
+#define g_rmdir rmdir
+#define g_fopen fopen
+#define g_freopen freopen
+
+#endif /* GLIB_CHECK_VERSION */
+
+#if !GLIB_CHECK_VERSION(2, 7, 0)
+
+#ifdef G_OS_UNIX
+#define g_chdir chdir
+#define g_chmod chmod
+#else
+gint g_chdir (const gchar *path);
+gint g_chmod (const gchar *path,
+ gint mode);
+#endif /* G_OS_UNIX */
+
+#endif /* !GLIB_CHECK_VERSION */
+
+/* The AC_CHECK_SIZEOF() in configure fails for some machines.
+ * we provide some fallback values here */
+#if !SIZEOF_UNSIGNED_SHORT
+ #undef SIZEOF_UNSIGNED_SHORT
+ #define SIZEOF_UNSIGNED_SHORT 2
+#endif
+#if !SIZEOF_UNSIGNED_INT
+ #undef SIZEOF_UNSIGNED_INT
+ #define SIZEOF_UNSIGNED_INT 4
+#endif
+#if !SIZEOF_UNSIGNED_LONG
+ #undef SIZEOF_UNSIGNED_LONG
+ #define SIZEOF_UNSIGNED_LONG 4
+#endif
+
+#ifndef HAVE_U32_TYPEDEF
+ #undef u32 /* maybe there is a macro with this name */
+ typedef guint32 u32;
+ #define HAVE_U32_TYPEDEF
+#endif
+
+#ifndef BIG_ENDIAN_HOST
+ #if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ #define BIG_ENDIAN_HOST 1
+ #endif
+#endif
+
+#define CHDIR_RETURN_IF_FAIL(dir) \
+{ \
+ if (change_dir(dir) < 0) return; \
+}
+
+#define CHDIR_RETURN_VAL_IF_FAIL(dir, val) \
+{ \
+ if (change_dir(dir) < 0) return val; \
+}
+
+#define Xalloca(ptr, size, iffail) \
+{ \
+ if ((ptr = alloca(size)) == NULL) { \
+ g_warning("can't allocate memory\n"); \
+ iffail; \
+ } \
+}
+
+#define Xstrdup_a(ptr, str, iffail) \
+{ \
+ gchar *__tmp; \
+ \
+ if ((__tmp = alloca(strlen(str) + 1)) == NULL) { \
+ g_warning("can't allocate memory\n"); \
+ iffail; \
+ } else \
+ strcpy(__tmp, str); \
+ \
+ ptr = __tmp; \
+}
+
+#define Xstrndup_a(ptr, str, len, iffail) \
+{ \
+ gchar *__tmp; \
+ \
+ if ((__tmp = alloca(len + 1)) == NULL) { \
+ g_warning("can't allocate memory\n"); \
+ iffail; \
+ } else { \
+ strncpy(__tmp, str, len); \
+ __tmp[len] = '\0'; \
+ } \
+ \
+ ptr = __tmp; \
+}
+
+#define Xstrcat_a(ptr, str1, str2, iffail) \
+{ \
+ gchar *__tmp; \
+ gint len1, len2; \
+ \
+ len1 = strlen(str1); \
+ len2 = strlen(str2); \
+ if ((__tmp = alloca(len1 + len2 + 1)) == NULL) { \
+ g_warning("can't allocate memory\n"); \
+ iffail; \
+ } else { \
+ memcpy(__tmp, str1, len1); \
+ memcpy(__tmp + len1, str2, len2 + 1); \
+ } \
+ \
+ ptr = __tmp; \
+}
+
+#define AUTORELEASE_STR(str, iffail) \
+{ \
+ gchar *__str; \
+ Xstrdup_a(__str, str, iffail); \
+ g_free(str); \
+ str = __str; \
+}
+
+#define FILE_OP_ERROR(file, func) \
+{ \
+ fprintf(stderr, "%s: ", file); \
+ fflush(stderr); \
+ perror(func); \
+}
+
+typedef void (*LogFunc) (const gchar *str);
+
+/* for macro expansion */
+#define Str(x) #x
+#define Xstr(x) Str(x)
+
+void list_free_strings (GList *list);
+void slist_free_strings (GSList *list);
+
+void hash_free_strings (GHashTable *table);
+void hash_free_value_mem (GHashTable *table);
+
+gint str_case_equal (gconstpointer v,
+ gconstpointer v2);
+guint str_case_hash (gconstpointer key);
+
+void ptr_array_free_strings (GPtrArray *array);
+
+typedef gboolean (*StrFindFunc) (const gchar *haystack,
+ const gchar *needle);
+
+gboolean str_find (const gchar *haystack,
+ const gchar *needle);
+gboolean str_case_find (const gchar *haystack,
+ const gchar *needle);
+gboolean str_find_equal (const gchar *haystack,
+ const gchar *needle);
+gboolean str_case_find_equal (const gchar *haystack,
+ const gchar *needle);
+
+/* number-string conversion */
+gint to_number (const gchar *nstr);
+gchar *itos_buf (gchar *nstr,
+ gint n);
+gchar *itos (gint n);
+gchar *to_human_readable (off_t size);
+
+/* alternative string functions */
+gint strcmp2 (const gchar *s1,
+ const gchar *s2);
+gint path_cmp (const gchar *s1,
+ const gchar *s2);
+gchar *strretchomp (gchar *str);
+gchar *strtailchomp (gchar *str,
+ gchar tail_char);
+gchar *strcrchomp (gchar *str);
+gchar *strcasestr (const gchar *haystack,
+ const gchar *needle);
+gpointer my_memmem (gconstpointer haystack,
+ size_t haystacklen,
+ gconstpointer needle,
+ size_t needlelen);
+gchar *strncpy2 (gchar *dest,
+ const gchar *src,
+ size_t n);
+
+/* wide-character functions */
+#if !HAVE_ISWALNUM
+int iswalnum (wint_t wc);
+#endif
+#if !HAVE_ISWSPACE
+int iswspace (wint_t wc);
+#endif
+#if !HAVE_TOWLOWER
+wint_t towlower (wint_t wc);
+#endif
+
+#if !HAVE_WCSLEN
+size_t wcslen (const wchar_t *s);
+#endif
+#if !HAVE_WCSCPY
+wchar_t *wcscpy (wchar_t *dest,
+ const wchar_t *src);
+#endif
+#if !HAVE_WCSNCPY
+wchar_t *wcsncpy (wchar_t *dest,
+ const wchar_t *src,
+ size_t n);
+#endif
+
+wchar_t *wcsdup (const wchar_t *s);
+wchar_t *wcsndup (const wchar_t *s,
+ size_t n);
+wchar_t *strdup_mbstowcs (const gchar *s);
+gchar *strdup_wcstombs (const wchar_t *s);
+gint wcsncasecmp (const wchar_t *s1,
+ const wchar_t *s2,
+ size_t n);
+wchar_t *wcscasestr (const wchar_t *haystack,
+ const wchar_t *needle);
+gint get_mbs_len (const gchar *s);
+
+gboolean is_next_nonascii (const gchar *s);
+gint get_next_word_len (const gchar *s);
+
+/* functions for string parsing */
+gint subject_compare (const gchar *s1,
+ const gchar *s2);
+gint subject_compare_for_sort (const gchar *s1,
+ const gchar *s2);
+void trim_subject_for_compare (gchar *str);
+void trim_subject_for_sort (gchar *str);
+void trim_subject (gchar *str);
+void eliminate_parenthesis (gchar *str,
+ gchar op,
+ gchar cl);
+void extract_parenthesis (gchar *str,
+ gchar op,
+ gchar cl);
+
+void extract_parenthesis_with_skip_quote (gchar *str,
+ gchar quote_chr,
+ gchar op,
+ gchar cl);
+
+void eliminate_quote (gchar *str,
+ gchar quote_chr);
+void extract_quote (gchar *str,
+ gchar quote_chr);
+void eliminate_address_comment (gchar *str);
+gchar *strchr_with_skip_quote (const gchar *str,
+ gint quote_chr,
+ gint c);
+gchar *strrchr_with_skip_quote (const gchar *str,
+ gint quote_chr,
+ gint c);
+void extract_address (gchar *str);
+void extract_list_id_str (gchar *str);
+
+GSList *address_list_append (GSList *addr_list,
+ const gchar *str);
+GSList *references_list_prepend (GSList *msgid_list,
+ const gchar *str);
+GSList *references_list_append (GSList *msgid_list,
+ const gchar *str);
+GSList *newsgroup_list_append (GSList *group_list,
+ const gchar *str);
+
+GList *add_history (GList *list,
+ const gchar *str);
+
+void remove_return (gchar *str);
+void remove_space (gchar *str);
+void unfold_line (gchar *str);
+void subst_char (gchar *str,
+ gchar orig,
+ gchar subst);
+void subst_chars (gchar *str,
+ gchar *orig,
+ gchar subst);
+void subst_null (gchar *str,
+ gint len,
+ gchar subst);
+void subst_for_filename (gchar *str);
+gboolean is_header_line (const gchar *str);
+gboolean is_ascii_str (const gchar *str);
+gint get_quote_level (const gchar *str);
+gint check_line_length (const gchar *str,
+ gint max_chars,
+ gint *line);
+
+gchar *strstr_with_skip_quote (const gchar *haystack,
+ const gchar *needle);
+gchar *strchr_parenthesis_close (const gchar *str,
+ gchar op,
+ gchar cl);
+
+gchar **strsplit_parenthesis (const gchar *str,
+ gchar op,
+ gchar cl,
+ gint max_tokens);
+gchar **strsplit_with_quote (const gchar *str,
+ const gchar *delim,
+ gint max_tokens);
+
+gchar *get_abbrev_newsgroup_name (const gchar *group,
+ gint len);
+gchar *trim_string (const gchar *str,
+ gint len);
+gchar *trim_string_before (const gchar *str,
+ gint len);
+
+GList *uri_list_extract_filenames (const gchar *uri_list);
+gboolean is_uri_string (const gchar *str);
+gchar *get_uri_path (const gchar *uri);
+gint get_uri_len (const gchar *str);
+void decode_uri (gchar *decoded_uri,
+ const gchar *encoded_uri);
+gchar *encode_uri (const gchar *filename);
+gint scan_mailto_url (const gchar *mailto,
+ gchar **to,
+ gchar **cc,
+ gchar **bcc,
+ gchar **subject,
+ gchar **body);
+
+/* return static strings */
+const gchar *get_home_dir (void);
+const gchar *get_rc_dir (void);
+const gchar *get_old_rc_dir (void);
+const gchar *get_mail_base_dir (void);
+const gchar *get_news_cache_dir (void);
+const gchar *get_imap_cache_dir (void);
+const gchar *get_mime_tmp_dir (void);
+const gchar *get_template_dir (void);
+const gchar *get_tmp_dir (void);
+gchar *get_tmp_file (void);
+const gchar *get_domain_name (void);
+
+/* file / directory handling */
+off_t get_file_size (const gchar *file);
+off_t get_file_size_as_crlf (const gchar *file);
+off_t get_left_file_size (FILE *fp);
+
+gboolean file_exist (const gchar *file,
+ gboolean allow_fifo);
+gboolean is_dir_exist (const gchar *dir);
+gboolean is_file_entry_exist (const gchar *file);
+gboolean dirent_is_regular_file (struct dirent *d);
+gboolean dirent_is_directory (struct dirent *d);
+
+#define is_file_exist(file) file_exist(file, FALSE)
+#define is_file_or_fifo_exist(file) file_exist(file, TRUE)
+
+gint change_dir (const gchar *dir);
+gint make_dir (const gchar *dir);
+gint make_dir_hier (const gchar *dir);
+gint remove_all_files (const gchar *dir);
+gint remove_numbered_files (const gchar *dir,
+ guint first,
+ guint last);
+gint remove_all_numbered_files (const gchar *dir);
+gint remove_expired_files (const gchar *dir,
+ guint hours);
+gint remove_dir_recursive (const gchar *dir);
+gint rename_force (const gchar *oldpath,
+ const gchar *newpath);
+gint copy_file (const gchar *src,
+ const gchar *dest,
+ gboolean keep_backup);
+gint copy_dir (const gchar *src,
+ const gchar *dest);
+gint move_file (const gchar *src,
+ const gchar *dest,
+ gboolean overwrite);
+gint copy_file_part (FILE *fp,
+ off_t offset,
+ size_t length,
+ const gchar *dest);
+
+gchar *canonicalize_str (const gchar *str);
+gint canonicalize_file (const gchar *src,
+ const gchar *dest);
+gint canonicalize_file_replace (const gchar *file);
+gint uncanonicalize_file (const gchar *src,
+ const gchar *dest);
+gint uncanonicalize_file_replace(const gchar *file);
+
+gchar *normalize_newlines (const gchar *str);
+
+gchar *get_outgoing_rfc2822_str (FILE *fp);
+gchar *generate_mime_boundary (const gchar *prefix);
+
+gint change_file_mode_rw (FILE *fp,
+ const gchar *file);
+FILE *my_tmpfile (void);
+FILE *str_open_as_stream (const gchar *str);
+gint str_write_to_file (const gchar *str,
+ const gchar *file);
+gchar *file_read_to_str (const gchar *file);
+gchar *file_read_stream_to_str (FILE *fp);
+
+/* process execution */
+gint execute_async (gchar *const argv[]);
+gint execute_sync (gchar *const argv[]);
+gint execute_command_line (const gchar *cmdline,
+ gboolean async);
+gchar *get_command_output (const gchar *cmdline);
+
+/* open URI with external browser */
+gint open_uri(const gchar *uri, const gchar *cmdline);
+
+/* time functions */
+time_t remote_tzoffset_sec (const gchar *zone);
+time_t tzoffset_sec (time_t *now);
+gchar *tzoffset (time_t *now);
+void get_rfc822_date (gchar *buf,
+ gint len);
+
+size_t my_strftime (gchar *s,
+ size_t max,
+ const gchar *format,
+ const struct tm *tm);
+
+/* logging */
+void set_log_file (const gchar *filename);
+void close_log_file (void);
+void set_log_verbosity (gboolean verbose);
+gboolean get_debug_mode (void);
+void set_debug_mode (gboolean enable);
+
+void set_log_ui_func (LogFunc print_func,
+ LogFunc message_func,
+ LogFunc warning_func,
+ LogFunc error_func);
+
+void set_log_show_status_func (LogFunc status_func);
+
+void debug_print (const gchar *format, ...) G_GNUC_PRINTF(1, 2);
+void log_print (const gchar *format, ...) G_GNUC_PRINTF(1, 2);
+void log_message (const gchar *format, ...) G_GNUC_PRINTF(1, 2);
+void log_warning (const gchar *format, ...) G_GNUC_PRINTF(1, 2);
+void log_error (const gchar *format, ...) G_GNUC_PRINTF(1, 2);
+
+#endif /* __UTILS_H__ */
diff --git a/libsylph/uuencode.c b/libsylph/uuencode.c
new file mode 100644
index 00000000..e0b2e79a
--- /dev/null
+++ b/libsylph/uuencode.c
@@ -0,0 +1,101 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999,2000 Hiroyuki Yamamoto
+ *
+ * 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 <ctype.h>
+
+#define UUDECODE(c) (c=='`' ? 0 : c - ' ')
+#define N64(i) (i & ~63)
+
+const char uudigit[64] =
+{
+ '`', '!', '"', '#', '$', '%', '&', '\'',
+ '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', ':', ';', '<', '=', '>', '?',
+ '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+ 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+ 'X', 'Y', 'Z', '[', '\\', ']', '^', '_'
+};
+
+int touufrombits(unsigned char *out, const unsigned char *in, int inlen)
+{
+ int len;
+
+ if (inlen > 45) return -1;
+ len = (inlen * 4 + 2) / 3 + 1;
+ *out++ = uudigit[inlen];
+
+ for (; inlen >= 3; inlen -= 3) {
+ *out++ = uudigit[in[0] >> 2];
+ *out++ = uudigit[((in[0] << 4) & 0x30) | (in[1] >> 4)];
+ *out++ = uudigit[((in[1] << 2) & 0x3c) | (in[2] >> 6)];
+ *out++ = uudigit[in[2] & 0x3f];
+ in += 3;
+ }
+
+ if (inlen > 0) {
+ *out++ = uudigit[(in[0] >> 2)];
+ if (inlen == 1) {
+ *out++ = uudigit[((in[0] << 4) & 0x30)];
+ } else {
+ *out++ = uudigit[(((in[0] << 4) & 0x30) | (in[1] >> 4))] ;
+ *out++ = uudigit[((in[1] << 2) & 0x3c)];
+ }
+ }
+ *out = '\0';
+
+ return len;
+}
+
+int fromuutobits(char *out, const char *in)
+{
+ int len, outlen, inlen;
+ register unsigned char digit1, digit2;
+
+ outlen = UUDECODE(in[0]);
+ in += 1;
+ if(outlen < 0 || outlen > 45)
+ return -2;
+ if(outlen == 0)
+ return 0;
+ inlen = (outlen * 4 + 2) / 3;
+ len = 0;
+
+ for( ; inlen>0; inlen-=4) {
+ digit1 = UUDECODE(in[0]);
+ if (N64(digit1)) return -1;
+ digit2 = UUDECODE(in[1]);
+ if (N64(digit2)) return -1;
+ out[len++] = (digit1 << 2) | (digit2 >> 4);
+ if (inlen > 2) {
+ digit1 = UUDECODE(in[2]);
+ if (N64(digit1)) return -1;
+ out[len++] = (digit2 << 4) | (digit1 >> 2);
+ if (inlen > 3) {
+ digit2 = UUDECODE(in[3]);
+ if (N64(digit2)) return -1;
+ out[len++] = (digit1 << 6) | digit2;
+ }
+ }
+ in += 4;
+ }
+
+ return len == outlen ? len : -3;
+}
diff --git a/libsylph/uuencode.h b/libsylph/uuencode.h
new file mode 100644
index 00000000..3658ebc6
--- /dev/null
+++ b/libsylph/uuencode.h
@@ -0,0 +1,24 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999,2000 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+void touufrombits(unsigned char *, const unsigned char *, int);
+int fromuutobits(char *, const char *);
+
+#define X_UUENCODE_END_LINE '`'
+#define UUENCODE_END_LINE ' '
diff --git a/libsylph/xml.c b/libsylph/xml.c
new file mode 100644
index 00000000..62a04829
--- /dev/null
+++ b/libsylph/xml.c
@@ -0,0 +1,655 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
+ *
+ * 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 <glib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "xml.h"
+#include "utils.h"
+#include "codeconv.h"
+
+#define SPARSE_MEMORY
+/* if this is defined all attr.names and tag.names are stored
+ * in a hash table */
+#if defined(SPARSE_MEMORY)
+#include "stringtable.h"
+
+static StringTable *xml_string_table;
+
+static void xml_string_table_create(void)
+{
+ if (xml_string_table == NULL)
+ xml_string_table = string_table_new();
+}
+#define XML_STRING_ADD(str) \
+ string_table_insert_string(xml_string_table, (str))
+#define XML_STRING_FREE(str) \
+ string_table_free_string(xml_string_table, (str))
+
+#define XML_STRING_TABLE_CREATE() \
+ xml_string_table_create()
+
+#else /* !SPARSE_MEMORY */
+
+#define XML_STRING_ADD(str) \
+ g_strdup(str)
+#define XML_STRING_FREE(str) \
+ g_free(str)
+
+#define XML_STRING_TABLE_CREATE()
+
+#endif /* SPARSE_MEMORY */
+
+static void xml_free_tag (XMLTag *tag);
+static gint xml_get_parenthesis (XMLFile *file,
+ gchar *buf,
+ gint len);
+
+XMLFile *xml_open_file(const gchar *path)
+{
+ XMLFile *newfile;
+
+ g_return_val_if_fail(path != NULL, NULL);
+
+ XML_STRING_TABLE_CREATE();
+
+ newfile = g_new(XMLFile, 1);
+
+ newfile->fp = g_fopen(path, "rb");
+ if (!newfile->fp) {
+ g_free(newfile);
+ return NULL;
+ }
+
+ newfile->buf = g_string_new(NULL);
+ newfile->bufp = newfile->buf->str;
+
+ newfile->dtd = NULL;
+ newfile->encoding = NULL;
+ newfile->tag_stack = NULL;
+ newfile->level = 0;
+ newfile->is_empty_element = FALSE;
+
+ return newfile;
+}
+
+void xml_close_file(XMLFile *file)
+{
+ g_return_if_fail(file != NULL);
+
+ if (file->fp) fclose(file->fp);
+
+ g_string_free(file->buf, TRUE);
+
+ g_free(file->dtd);
+ g_free(file->encoding);
+
+ while (file->tag_stack != NULL)
+ xml_pop_tag(file);
+
+ g_free(file);
+}
+
+static GNode *xml_build_tree(XMLFile *file, GNode *parent, guint level)
+{
+ GNode *node = NULL;
+ XMLNode *xmlnode;
+ XMLTag *tag;
+
+ while (xml_parse_next_tag(file) == 0) {
+ if (file->level < level) break;
+ if (file->level == level) {
+ g_warning("xml_build_tree(): Parse error\n");
+ break;
+ }
+
+ tag = xml_get_current_tag(file);
+ if (!tag) break;
+ xmlnode = xml_node_new(xml_copy_tag(tag), NULL);
+ xmlnode->element = xml_get_element(file);
+ if (!parent)
+ node = g_node_new(xmlnode);
+ else
+ node = g_node_append_data(parent, xmlnode);
+
+ xml_build_tree(file, node, file->level);
+ if (file->level == 0) break;
+ }
+
+ return node;
+}
+
+GNode *xml_parse_file(const gchar *path)
+{
+ XMLFile *file;
+ GNode *node;
+
+ file = xml_open_file(path);
+ g_return_val_if_fail(file != NULL, NULL);
+
+ xml_get_dtd(file);
+
+ node = xml_build_tree(file, NULL, file->level);
+
+ xml_close_file(file);
+
+#if defined(SPARSE_MEMORY)
+ if (get_debug_mode())
+ string_table_get_stats(xml_string_table);
+#endif
+
+ return node;
+}
+
+gint xml_get_dtd(XMLFile *file)
+{
+ gchar buf[XMLBUFSIZE];
+ gchar *bufp = buf;
+
+ if (xml_get_parenthesis(file, buf, sizeof(buf)) < 0) return -1;
+
+ if ((*bufp++ == '?') &&
+ (bufp = strcasestr(bufp, "xml")) &&
+ (bufp = strcasestr(bufp + 3, "version")) &&
+ (bufp = strchr(bufp + 7, '?'))) {
+ file->dtd = g_strdup(buf);
+ if ((bufp = strcasestr(buf, "encoding=\""))) {
+ bufp += 9;
+ extract_quote(bufp, '"');
+ file->encoding = g_strdup(bufp);
+ } else
+ file->encoding = g_strdup(CS_INTERNAL);
+ } else {
+ g_warning("Can't get xml dtd\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+gint xml_parse_next_tag(XMLFile *file)
+{
+ gchar buf[XMLBUFSIZE];
+ gchar *bufp = buf;
+ gchar *tag_str;
+ XMLTag *tag;
+ gint len;
+
+ if (file->is_empty_element == TRUE) {
+ file->is_empty_element = FALSE;
+ xml_pop_tag(file);
+ return 0;
+ }
+
+ if (xml_get_parenthesis(file, buf, sizeof(buf)) < 0) {
+ g_warning("xml_parse_next_tag(): Can't parse next tag\n");
+ return -1;
+ }
+
+ /* end-tag */
+ if (buf[0] == '/') {
+ if (strcmp(xml_get_current_tag(file)->tag, buf + 1) != 0) {
+ g_warning("xml_parse_next_tag(): Tag name mismatch: %s\n", buf);
+ return -1;
+ }
+ xml_pop_tag(file);
+ return 0;
+ }
+
+ tag = xml_tag_new(NULL);
+ xml_push_tag(file, tag);
+
+ len = strlen(buf);
+ if (len > 0 && buf[len - 1] == '/') {
+ file->is_empty_element = TRUE;
+ buf[len - 1] = '\0';
+ g_strchomp(buf);
+ }
+ if (strlen(buf) == 0) {
+ g_warning("xml_parse_next_tag(): Tag name is empty\n");
+ return -1;
+ }
+
+ while (*bufp != '\0' && !g_ascii_isspace(*bufp)) bufp++;
+ if (*bufp == '\0') {
+ tag_str = conv_codeset_strdup(buf, file->encoding, CS_INTERNAL);
+ if (tag_str) {
+ tag->tag = XML_STRING_ADD(tag_str);
+ g_free(tag_str);
+ } else
+ tag->tag = XML_STRING_ADD(buf);
+ return 0;
+ } else {
+ *bufp++ = '\0';
+ tag_str = conv_codeset_strdup(buf, file->encoding, CS_INTERNAL);
+ if (tag_str) {
+ tag->tag = XML_STRING_ADD(tag_str);
+ g_free(tag_str);
+ } else
+ tag->tag = XML_STRING_ADD(buf);
+ }
+
+ /* parse attributes ( name=value ) */
+ while (*bufp) {
+ XMLAttr *attr;
+ gchar *attr_name;
+ gchar *attr_value;
+ gchar *utf8_attr_name;
+ gchar *utf8_attr_value;
+ gchar *p;
+ gchar quote;
+
+ while (g_ascii_isspace(*bufp)) bufp++;
+ attr_name = bufp;
+ if ((p = strchr(attr_name, '=')) == NULL) {
+ g_warning("xml_parse_next_tag(): Syntax error in tag\n");
+ return -1;
+ }
+ bufp = p;
+ *bufp++ = '\0';
+ while (g_ascii_isspace(*bufp)) bufp++;
+
+ if (*bufp != '"' && *bufp != '\'') {
+ g_warning("xml_parse_next_tag(): Syntax error in tag\n");
+ return -1;
+ }
+ quote = *bufp;
+ bufp++;
+ attr_value = bufp;
+ if ((p = strchr(attr_value, quote)) == NULL) {
+ g_warning("xml_parse_next_tag(): Syntax error in tag\n");
+ return -1;
+ }
+ bufp = p;
+ *bufp++ = '\0';
+
+ g_strchomp(attr_name);
+ xml_unescape_str(attr_value);
+ utf8_attr_name = conv_codeset_strdup
+ (attr_name, file->encoding, CS_INTERNAL);
+ utf8_attr_value = conv_codeset_strdup
+ (attr_value, file->encoding, CS_INTERNAL);
+ if (!utf8_attr_name)
+ utf8_attr_name = g_strdup(attr_name);
+ if (!utf8_attr_value)
+ utf8_attr_value = g_strdup(attr_value);
+
+ attr = xml_attr_new(utf8_attr_name, utf8_attr_value);
+ xml_tag_add_attr(tag, attr);
+
+ g_free(utf8_attr_value);
+ g_free(utf8_attr_name);
+ }
+
+ return 0;
+}
+
+void xml_push_tag(XMLFile *file, XMLTag *tag)
+{
+ g_return_if_fail(tag != NULL);
+
+ file->tag_stack = g_list_prepend(file->tag_stack, tag);
+ file->level++;
+}
+
+void xml_pop_tag(XMLFile *file)
+{
+ XMLTag *tag;
+
+ if (!file->tag_stack) return;
+
+ tag = (XMLTag *)file->tag_stack->data;
+
+ xml_free_tag(tag);
+ file->tag_stack = g_list_remove(file->tag_stack, tag);
+ file->level--;
+}
+
+XMLTag *xml_get_current_tag(XMLFile *file)
+{
+ if (file->tag_stack)
+ return (XMLTag *)file->tag_stack->data;
+ else
+ return NULL;
+}
+
+GList *xml_get_current_tag_attr(XMLFile *file)
+{
+ XMLTag *tag;
+
+ tag = xml_get_current_tag(file);
+ if (!tag) return NULL;
+
+ return tag->attr;
+}
+
+gchar *xml_get_element(XMLFile *file)
+{
+ gchar *str;
+ gchar *new_str;
+ gchar *end;
+
+ while ((end = strchr(file->bufp, '<')) == NULL)
+ if (xml_read_line(file) < 0) return NULL;
+
+ if (end == file->bufp)
+ return NULL;
+
+ str = g_strndup(file->bufp, end - file->bufp);
+ /* this is not XML1.0 strict */
+ g_strstrip(str);
+ xml_unescape_str(str);
+
+ file->bufp = end;
+ xml_truncate_buf(file);
+
+ if (str[0] == '\0') {
+ g_free(str);
+ return NULL;
+ }
+
+ new_str = conv_codeset_strdup(str, file->encoding, CS_INTERNAL);
+ if (!new_str)
+ new_str = g_strdup(str);
+ g_free(str);
+
+ return new_str;
+}
+
+gint xml_read_line(XMLFile *file)
+{
+ gchar buf[XMLBUFSIZE];
+ gint index;
+
+ if (fgets(buf, sizeof(buf), file->fp) == NULL)
+ return -1;
+
+ index = file->bufp - file->buf->str;
+
+ g_string_append(file->buf, buf);
+
+ file->bufp = file->buf->str + index;
+
+ return 0;
+}
+
+void xml_truncate_buf(XMLFile *file)
+{
+ gint len;
+
+ len = file->bufp - file->buf->str;
+ if (len > 0) {
+ g_string_erase(file->buf, 0, len);
+ file->bufp = file->buf->str;
+ }
+}
+
+gboolean xml_compare_tag(XMLFile *file, const gchar *name)
+{
+ XMLTag *tag;
+
+ tag = xml_get_current_tag(file);
+
+ if (tag && strcmp(tag->tag, name) == 0)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+XMLNode *xml_node_new(XMLTag *tag, const gchar *text)
+{
+ XMLNode *node;
+
+ node = g_new(XMLNode, 1);
+ node->tag = tag;
+ node->element = g_strdup(text);
+
+ return node;
+}
+
+XMLTag *xml_tag_new(const gchar *tag)
+{
+ XMLTag *new_tag;
+
+ new_tag = g_new(XMLTag, 1);
+ if (tag)
+ new_tag->tag = XML_STRING_ADD(tag);
+ else
+ new_tag->tag = NULL;
+ new_tag->attr = NULL;
+
+ return new_tag;
+}
+
+XMLAttr *xml_attr_new(const gchar *name, const gchar *value)
+{
+ XMLAttr *new_attr;
+
+ new_attr = g_new(XMLAttr, 1);
+ new_attr->name = XML_STRING_ADD(name);
+ new_attr->value = g_strdup(value);
+
+ return new_attr;
+}
+
+void xml_tag_add_attr(XMLTag *tag, XMLAttr *attr)
+{
+ tag->attr = g_list_append(tag->attr, attr);
+}
+
+XMLTag *xml_copy_tag(XMLTag *tag)
+{
+ XMLTag *new_tag;
+ XMLAttr *attr;
+ GList *list;
+
+ new_tag = xml_tag_new(tag->tag);
+ for (list = tag->attr; list != NULL; list = list->next) {
+ attr = xml_copy_attr((XMLAttr *)list->data);
+ xml_tag_add_attr(new_tag, attr);
+ }
+
+ return new_tag;
+}
+
+XMLAttr *xml_copy_attr(XMLAttr *attr)
+{
+ return xml_attr_new(attr->name, attr->value);
+}
+
+gint xml_unescape_str(gchar *str)
+{
+ gchar *start;
+ gchar *end;
+ gchar *p = str;
+ gchar *esc_str;
+ gchar ch;
+ gint len;
+
+ while ((start = strchr(p, '&')) != NULL) {
+ if ((end = strchr(start + 1, ';')) == NULL) {
+ g_warning("Unescaped `&' appeared\n");
+ p = start + 1;
+ continue;
+ }
+ len = end - start + 1;
+ if (len < 3) {
+ p = end + 1;
+ continue;
+ }
+
+ Xstrndup_a(esc_str, start, len, return -1);
+ if (!strcmp(esc_str, "&lt;"))
+ ch = '<';
+ else if (!strcmp(esc_str, "&gt;"))
+ ch = '>';
+ else if (!strcmp(esc_str, "&amp;"))
+ ch = '&';
+ else if (!strcmp(esc_str, "&apos;"))
+ ch = '\'';
+ else if (!strcmp(esc_str, "&quot;"))
+ ch = '\"';
+ else {
+ p = end + 1;
+ continue;
+ }
+
+ *start = ch;
+ memmove(start + 1, end + 1, strlen(end + 1) + 1);
+ p = start + 1;
+ }
+
+ return 0;
+}
+
+gint xml_file_put_escape_str(FILE *fp, const gchar *str)
+{
+ const gchar *p;
+
+ g_return_val_if_fail(fp != NULL, -1);
+
+ if (!str) return 0;
+
+ for (p = str; *p != '\0'; p++) {
+ switch (*p) {
+ case '<':
+ fputs("&lt;", fp);
+ break;
+ case '>':
+ fputs("&gt;", fp);
+ break;
+ case '&':
+ fputs("&amp;", fp);
+ break;
+ case '\'':
+ fputs("&apos;", fp);
+ break;
+ case '\"':
+ fputs("&quot;", fp);
+ break;
+ default:
+ fputc(*p, fp);
+ }
+ }
+
+ return 0;
+}
+
+gint xml_file_put_xml_decl(FILE *fp)
+{
+ g_return_val_if_fail(fp != NULL, -1);
+
+ fprintf(fp, "<?xml version=\"1.0\" encoding=\"%s\"?>\n", CS_INTERNAL);
+ return 0;
+}
+
+gint xml_file_put_node(FILE *fp, XMLNode *node)
+{
+ GList *cur;
+
+ g_return_val_if_fail(fp != NULL, -1);
+ g_return_val_if_fail(node != NULL, -1);
+
+ fprintf(fp, "<%s", node->tag->tag);
+
+ for (cur = node->tag->attr; cur != NULL; cur = cur->next) {
+ XMLAttr *attr = (XMLAttr *)cur->data;
+ fprintf(fp, " %s=\"", attr->name);
+ xml_file_put_escape_str(fp, attr->value);
+ fputs("\"", fp);
+ }
+
+ if (node->element) {
+ fputs(">", fp);
+ xml_file_put_escape_str(fp, node->element);
+ fprintf(fp, "</%s>\n", node->tag->tag);
+ } else {
+ fputs(" />\n", fp);
+ }
+
+ return 0;
+}
+
+void xml_free_node(XMLNode *node)
+{
+ if (!node) return;
+
+ xml_free_tag(node->tag);
+ g_free(node->element);
+ g_free(node);
+}
+
+static gboolean xml_free_func(GNode *node, gpointer data)
+{
+ XMLNode *xmlnode = node->data;
+
+ xml_free_node(xmlnode);
+ return FALSE;
+}
+
+void xml_free_tree(GNode *node)
+{
+ g_return_if_fail(node != NULL);
+
+ g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, xml_free_func,
+ NULL);
+
+ g_node_destroy(node);
+}
+
+static void xml_free_tag(XMLTag *tag)
+{
+ if (!tag) return;
+
+ XML_STRING_FREE(tag->tag);
+ while (tag->attr != NULL) {
+ XMLAttr *attr = (XMLAttr *)tag->attr->data;
+ XML_STRING_FREE(attr->name);
+ g_free(attr->value);
+ g_free(attr);
+ tag->attr = g_list_remove(tag->attr, tag->attr->data);
+ }
+ g_free(tag);
+}
+
+static gint xml_get_parenthesis(XMLFile *file, gchar *buf, gint len)
+{
+ gchar *start;
+ gchar *end;
+
+ buf[0] = '\0';
+
+ while ((start = strchr(file->bufp, '<')) == NULL)
+ if (xml_read_line(file) < 0) return -1;
+
+ start++;
+ file->bufp = start;
+
+ while ((end = strchr(file->bufp, '>')) == NULL)
+ if (xml_read_line(file) < 0) return -1;
+
+ strncpy2(buf, file->bufp, MIN(end - file->bufp + 1, len));
+ g_strstrip(buf);
+ file->bufp = end + 1;
+ xml_truncate_buf(file);
+
+ return 0;
+}
diff --git a/libsylph/xml.h b/libsylph/xml.h
new file mode 100644
index 00000000..b41449a4
--- /dev/null
+++ b/libsylph/xml.h
@@ -0,0 +1,108 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2004 Hiroyuki Yamamoto
+ *
+ * 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.
+ */
+
+#ifndef __XML_H__
+#define __XML_H__
+
+#include <glib.h>
+#include <stdio.h>
+
+#define XMLBUFSIZE 8192
+
+typedef struct _XMLAttr XMLAttr;
+typedef struct _XMLTag XMLTag;
+typedef struct _XMLNode XMLNode;
+typedef struct _XMLFile XMLFile;
+
+struct _XMLAttr
+{
+ gchar *name;
+ gchar *value;
+};
+
+struct _XMLTag
+{
+ gchar *tag;
+ GList *attr;
+};
+
+struct _XMLNode
+{
+ XMLTag *tag;
+ gchar *element;
+};
+
+struct _XMLFile
+{
+ FILE *fp;
+
+ GString *buf;
+ gchar *bufp;
+
+ gchar *dtd;
+ gchar *encoding;
+
+ GList *tag_stack;
+ guint level;
+
+ gboolean is_empty_element;
+};
+
+XMLFile *xml_open_file (const gchar *path);
+void xml_close_file (XMLFile *file);
+GNode *xml_parse_file (const gchar *path);
+
+gint xml_get_dtd (XMLFile *file);
+gint xml_parse_next_tag (XMLFile *file);
+void xml_push_tag (XMLFile *file,
+ XMLTag *tag);
+void xml_pop_tag (XMLFile *file);
+
+XMLTag *xml_get_current_tag (XMLFile *file);
+GList *xml_get_current_tag_attr(XMLFile *file);
+gchar *xml_get_element (XMLFile *file);
+
+gint xml_read_line (XMLFile *file);
+void xml_truncate_buf (XMLFile *file);
+gboolean xml_compare_tag (XMLFile *file,
+ const gchar *name);
+
+XMLNode *xml_node_new (XMLTag *tag,
+ const gchar *text);
+XMLTag *xml_tag_new (const gchar *tag);
+XMLAttr *xml_attr_new (const gchar *name,
+ const gchar *value);
+void xml_tag_add_attr (XMLTag *tag,
+ XMLAttr *attr);
+
+XMLTag *xml_copy_tag (XMLTag *tag);
+XMLAttr *xml_copy_attr (XMLAttr *attr);
+
+gint xml_unescape_str (gchar *str);
+gint xml_file_put_escape_str (FILE *fp,
+ const gchar *str);
+
+gint xml_file_put_xml_decl (FILE *fp);
+gint xml_file_put_node (FILE *fp,
+ XMLNode *node);
+
+void xml_free_node (XMLNode *node);
+void xml_free_tree (GNode *node);
+
+#endif /* __XML_H__ */
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-29 12:40:38 +0000