/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2001 Hiroyuki Yamamoto
+ * 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
#include "intl.h"
#include "utils.h"
+#include "socket.h"
#include "statusbar.h"
#include "logwindow.h"
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);
+}
+
void ptr_array_free_strings(GPtrArray *array)
{
gint i;
gchar *to_human_readable(off_t size)
{
- static gchar str[9];
- gint count;
- guint32 div = 1;
-
- for (count = 0; count < 3; count++) {
- if (size / div < 1024)
- break;
- else
- div *= 1024;
- }
+ static gchar str[10];
- switch (count) {
- case 0: g_snprintf(str, sizeof(str), "%dB", (gint)size); break;
- case 1: g_snprintf(str, sizeof(str), "%.1fKB", (gfloat)size / div);
- break;
- case 2: g_snprintf(str, sizeof(str), "%.1fMB", (gfloat)size / div);
- break;
- default:
- g_snprintf(str, sizeof(str), "%.1fGB", (gfloat)size / div);
- break;
- }
+ 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;
}
else
return strcmp(s1, s2);
}
-
+/* strstr with NULL-checking */
+gchar *strstr2(const gchar *s1, const gchar *s2)
+{
+ if (s1 == NULL || s2 == NULL)
+ return NULL;
+ else
+ return strstr(s1, s2);
+}
/* compare paths */
gint path_cmp(const gchar *s1, const gchar *s2)
{
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)
{
gint mbl;
const wchar_t *wp;
- gchar tmp[MB_CUR_MAX];
+ gchar tmp[MB_LEN_MAX];
/* skip head space */
for (wp = s; *wp != (wchar_t)0 && iswspace(*wp); wp++)
/* compare subjects */
gint subject_compare(const gchar *s1, const gchar *s2)
{
- gint retval;
gchar *str1, *str2;
if (!s1 || !s2) return -1;
if (!*s1 || !*s2) return -1;
- Xalloca(str1, strlen(s1) + 1, return -1);
- Xalloca(str2, strlen(s2) + 1, return -1);
- strcpy(str1, s1);
- strcpy(str2, s2);
+ Xstrdup_a(str1, s1, return -1);
+ Xstrdup_a(str2, s2, return -1);
trim_subject(str1);
trim_subject(str2);
if (!*str1 || !*str2) return -1;
- retval = strcmp(str1, str2);
- //if (retval == 0)
- // g_print("\ns1 = %s\ns2 = %s\n"
- // "str1 = %s\nstr2 = %s\nmatched.\n",
- // s1, s2, str1, str2);
-
- return retval;
+ return strcmp(str1, str2);
}
void trim_subject(gchar *str)
register gchar *p;
if ((str = strchr(str, quote_chr))) {
- if ((p = strchr(str + 1, quote_chr))) {
+ p = str;
+ while ((p = strchr(p + 1, quote_chr)) && (p[-1] == '\\')) {
+ memmove(p - 1, p, strlen(p) + 1);
+ p--;
+ }
+ if(p) {
*p = '\0';
memmove(str, str + 1, p - str);
}
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;
}
}
+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_for_filename(gchar *str)
+{
+ subst_chars(str, " \t\r\n\"/\\", '_');
+}
+
gboolean is_header_line(const gchar *str)
{
if (str[0] == ':') return FALSE;
return TRUE;
}
-gint get_quote_level(const gchar *str)
+gint get_quote_level(const gchar *str, const gchar *quote_chars)
{
- size_t firstquotepos;
- size_t lastquotepos = -1;
+ const gchar *first_pos;
+ const gchar *last_pos;
const gchar *p = str;
- const gchar *pos;
- gint quotelevel = -1;
- gint i = 0;
+ gint quote_level = -1;
/* speed up line processing by only searching to the last '>' */
- if ((pos = strchr(str, '>')) != NULL) {
- firstquotepos = pos - str;
- lastquotepos = strrchr(str, '>') - str + 1;
-
+ if ((first_pos = line_has_quote_char(str, quote_chars)) != NULL) {
/* skip a line if it contains a '<' before the initial '>' */
- if (memchr(str, '<', pos - str) != NULL)
+ if (memchr(str, '<', first_pos - str) != NULL)
return -1;
+ last_pos = line_has_quote_char_last(first_pos, quote_chars);
} else
return -1;
- while (i < lastquotepos) {
- while (i < lastquotepos) {
- if (isspace(*p) || (*p == '\t')) {
+ while (p <= last_pos) {
+ while (p < last_pos) {
+ if (isspace(*p))
p++;
- i++;
- } else
+ else
break;
}
- if (i >= lastquotepos)
- break;
- if (*p == '>')
- quotelevel++;
- else if ((*p != '-') && !isspace(*p) && (i < lastquotepos)) {
+ if (strchr(quote_chars, *p))
+ quote_level++;
+ else if (*p != '-' && !isspace(*p) && p <= last_pos) {
/* any characters are allowed except '-' and space */
- while ((*p != '-') && (*p != '>') && !isspace(*p) &&
- (i < lastquotepos)) {
+ while (*p != '-'
+ && !strchr(quote_chars, *p)
+ && !isspace(*p)
+ && p < last_pos)
p++;
- i++;
- }
- if (*p == '>')
- quotelevel++;
- else if ((i >= lastquotepos) || isspace(*p))
+ if (strchr(quote_chars, *p))
+ quote_level++;
+ else
break;
}
p++;
- i++;
}
- return quotelevel;
+ return quote_level;
}
-GList *uri_list_extract_filenames(const gchar *uri_list)
+const gchar * line_has_quote_char(const gchar * str, const gchar *quote_chars)
{
- GList *result = NULL;
- const gchar *p, *q;
- gchar *file;
+ gchar * position = NULL;
+ gchar * tmp_pos = NULL;
+ int i;
- p = uri_list;
+ if (quote_chars == NULL)
+ return FALSE;
+
+ for (i = 0; i < strlen(quote_chars); i++) {
+ tmp_pos = strchr (str, quote_chars[i]);
+ if(position == NULL
+ || (tmp_pos != NULL && position >= tmp_pos) )
+ position = tmp_pos;
+ }
+ return position;
+}
- while (p) {
- if (*p != '#') {
- while (isspace(*p)) p++;
- if (!strncmp(p, "file:", 5)) {
- p += 5;
- q = p;
- while (*q && *q != '\n' && *q != '\r') q++;
+const gchar * line_has_quote_char_last(const gchar * str, const gchar *quote_chars)
+{
+ gchar * position = NULL;
+ gchar * tmp_pos = NULL;
+ int i;
- if (q > p) {
- q--;
- while (q > p && isspace(*q)) q--;
- file = g_malloc(q - p + 2);
- strncpy(file, p, q - p + 1);
- file[q - p + 1] = '\0';
- result = g_list_append(result,file);
- }
- }
- }
- p = strchr(p, '\n');
- if (p) p++;
+ if (quote_chars == NULL)
+ return FALSE;
+
+ for (i = 0; i < strlen(quote_chars); i++) {
+ tmp_pos = strrchr (str, quote_chars[i]);
+ if(position == NULL
+ || (tmp_pos != NULL && position <= tmp_pos) )
+ position = tmp_pos;
}
-
- return result;
+ return position;
}
gchar *strstr_with_skip_quote(const gchar *haystack, const gchar *needle)
return NULL;
}
-/* this fuction was taken from gstrfuncs.c in glib. */
+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 && 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;
- guint i, n = 1;
+ 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);
guint delimiter_len = strlen(delim);
do {
- guint len;
- gchar *new_str;
-
len = s - str;
- new_str = g_new(gchar, len + 1);
- strncpy(new_str, str, len);
- new_str[len] = 0;
+ 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;
}
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++;
- string_list = g_slist_prepend(string_list, g_strdup(str));
}
str_array = g_new(gchar*, n);
return str_array;
}
+gchar *get_abbrev_newsgroup_name(const gchar *group)
+{
+ gchar *abbrev_group;
+ gchar *ap;
+ const gchar *p = group;
+
+ abbrev_group = ap = g_malloc(strlen(group) + 1);
+
+ while (*p) {
+ while (*p == '.')
+ *ap++ = *p++;
+ if (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);
+
+ while (*p != '\0') {
+ mb_len = mblen(p, MB_LEN_MAX);
+ if (mb_len == 0)
+ break;
+ else if (mb_len < 0)
+ return g_strdup(str);
+ else if (new_len + mb_len > len)
+ break;
+ else
+ new_len += mb_len;
+ p += mb_len;
+ }
+
+ Xstrndup_a(new_str, str, new_len, return g_strdup(str));
+ return g_strconcat(new_str, "...", 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 (isspace(*p)) p++;
+ if (!strncmp(p, "file:", 5)) {
+ p += 5;
+ q = p;
+ while (*q && *q != '\n' && *q != '\r') q++;
+
+ if (q > p) {
+ q--;
+ while (q > p && isspace(*q)) q--;
+ file = g_malloc(q - p + 2);
+ strncpy(file, p, q - p + 1);
+ file[q - p + 1] = '\0';
+ 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; \
+ } \
+}
+
/*
* We need this wrapper around g_get_home_dir(), so that
* we can fix some Windoze things here. Should be done in glibc of course
- * but as long as we are not able to do our own extensions to glibc, we do
+ * but as long as we are not able to do our own extensions to glibc, we do
* it here.
*/
gchar *get_home_dir(void)
return mime_tmp_dir;
}
+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;
+}
+
+gchar *get_header_cache_dir(void)
+{
+ static gchar *header_dir = NULL;
+
+ if (!header_dir)
+ header_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ HEADER_CACHE_DIR, NULL);
+
+ return header_dir;
+}
+
+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)
{
static gchar *tmp_file = NULL;
if (!tmp_file)
- tmp_file = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ tmp_file = g_strconcat(get_tmp_dir(), G_DIR_SEPARATOR_S,
"tmpfile", NULL);
return tmp_file;
static gchar *domain_name = NULL;
if (!domain_name) {
- gchar buf[BUFFSIZE] = "";
+ gchar buf[128] = "";
+ struct hostent *hp;
if (gethostname(buf, sizeof(buf)) < 0) {
perror("gethostname");
- strcpy(buf, "unknown");
+ 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);
+ }
}
- domain_name = g_strdup(buf);
+ debug_print("domain name = %s\n", domain_name);
}
return domain_name;
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 = 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;
return FALSE;
}
+gboolean is_file_entry_exist(const gchar *file)
+{
+ struct stat s;
+
+ if (stat(file, &s) < 0) {
+ if (ENOENT != errno) FILE_OP_ERROR(file, "stat");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
gint change_dir(const gchar *dir)
{
gchar *prevdir = NULL;
return 0;
}
+gint make_dir(const gchar *dir)
+{
+ if (mkdir(dir, S_IRWXU) < 0) {
+ FILE_OP_ERROR(dir, "mkdir");
+ return -1;
+ }
+ if (chmod(dir, S_IRWXU) < 0)
+ FILE_OP_ERROR(dir, "chmod");
+
+ return 0;
+}
+
gint make_dir_hier(const gchar *dir)
{
gchar *parent_dir;
parent_dir = g_strndup(dir, p - dir);
if (*parent_dir != '\0') {
if (!is_dir_exist(parent_dir)) {
- if (mkdir(parent_dir, S_IRWXU) < 0) {
- FILE_OP_ERROR(parent_dir, "mkdir");
+ if (make_dir(parent_dir) < 0) {
g_free(parent_dir);
return -1;
}
- if (chmod(parent_dir, S_IRWXU) < 0)
- FILE_OP_ERROR(parent_dir, "chmod");
}
}
g_free(parent_dir);
}
+
if (!is_dir_exist(dir)) {
- if (mkdir(dir, S_IRWXU) < 0) {
- FILE_OP_ERROR(dir, "mkdir");
+ if (make_dir(dir) < 0)
return -1;
- }
- if (chmod(dir, S_IRWXU) < 0)
- FILE_OP_ERROR(dir, "chmod");
}
return 0;
while ((d = readdir(dp)) != NULL) {
fileno = to_number(d->d_name);
if (fileno >= 0 && first <= fileno && fileno <= last) {
+ if (is_dir_exist(d->d_name))
+ continue;
if (unlink(d->d_name) < 0)
FILE_OP_ERROR(d->d_name, "unlink");
}
return remove_numbered_files(dir, 0, UINT_MAX);
}
+gint remove_expired_files(const gchar *dir, guint hours)
+{
+ DIR *dp;
+ struct dirent *d;
+ struct stat s;
+ gchar *prev_dir;
+ gint fileno;
+ time_t mtime, now, expire_time;
+
+ prev_dir = g_get_current_dir();
+
+ if (chdir(dir) < 0) {
+ FILE_OP_ERROR(dir, "chdir");
+ return -1;
+ }
+
+ if ((dp = opendir(".")) == NULL) {
+ FILE_OP_ERROR(dir, "opendir");
+ return -1;
+ }
+
+ now = time(NULL);
+ expire_time = hours * 60 * 60;
+
+ while ((d = readdir(dp)) != NULL) {
+ fileno = to_number(d->d_name);
+ if (fileno >= 0) {
+ if (stat(d->d_name, &s) < 0) {
+ FILE_OP_ERROR(d->d_name, "stat");
+ continue;
+ }
+ if (S_ISDIR(s.st_mode))
+ continue;
+ mtime = MAX(s.st_mtime, s.st_atime);
+ if (now - mtime > expire_time) {
+ if (unlink(d->d_name) < 0)
+ FILE_OP_ERROR(d->d_name, "unlink");
+ }
+ }
+ }
+
+ closedir(dp);
+
+ if (chdir(prev_dir) < 0) {
+ FILE_OP_ERROR(prev_dir, "chdir");
+ g_free(prev_dir);
+ return -1;
+ }
+
+ g_free(prev_dir);
+
+ return 0;
+}
+
gint remove_dir_recursive(const gchar *dir)
{
struct stat s;
struct dirent *d;
gchar *prev_dir;
- //g_print("dir = %s\n", dir);
+ /* g_print("dir = %s\n", dir); */
if (stat(dir, &s) < 0) {
FILE_OP_ERROR(dir, "stat");
}
prev_dir = g_get_current_dir();
- //g_print("prev_dir = %s\n", prev_dir);
+ /* g_print("prev_dir = %s\n", prev_dir); */
if (!path_cmp(prev_dir, dir)) {
g_free(prev_dir);
continue;
}
- //g_print("removing %s\n", d->d_name);
+ /* g_print("removing %s\n", d->d_name); */
if (S_ISDIR(s.st_mode)) {
if (remove_dir_recursive(d->d_name) < 0) {
}
#endif
-gint copy_file(const gchar *src, const gchar *dest)
+gint copy_file(const gchar *src, const gchar *dest, gboolean keep_backup)
{
FILE *src_fp, *dest_fp;
gint n_read;
gchar *dest_bak = NULL;
gboolean err = FALSE;
- if ((src_fp = fopen(src, "r")) == NULL) {
+ if ((src_fp = fopen(src, "rb")) == NULL) {
FILE_OP_ERROR(src, "fopen");
return -1;
}
}
}
- if ((dest_fp = fopen(dest, "w")) == NULL) {
+ if ((dest_fp = fopen(dest, "wb")) == NULL) {
FILE_OP_ERROR(dest, "fopen");
fclose(src_fp);
if (dest_bak) {
return -1;
}
+ if (keep_backup == FALSE && dest_bak)
+ unlink(dest_bak);
+
g_free(dest_bak);
return 0;
}
-gint move_file(const gchar *src, const gchar *dest)
+gint move_file(const gchar *src, const gchar *dest, gboolean overwrite)
{
- if (is_file_exist(dest)) {
- g_warning(_("move_file(): file %s already exists."), dest);
+ if (overwrite == FALSE && is_file_exist(dest)) {
+ g_warning("move_file(): file %s already exists.", dest);
return -1;
}
return -1;
}
- if (copy_file(src, dest) < 0) return -1;
+ if (copy_file(src, dest, FALSE) < 0) return -1;
unlink(src);
return 0;
}
+/* convert line endings into CRLF. If the last line doesn't end with
+ * linebreak, add it.
+ */
+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 = fopen(src, "rb")) == NULL) {
+ FILE_OP_ERROR(src, "fopen");
+ return -1;
+ }
+
+ if ((dest_fp = 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);
+ 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, "fread");
+ err = TRUE;
+ }
+ fclose(src_fp);
+ if (fclose(dest_fp) == EOF) {
+ FILE_OP_ERROR(dest, "fclose");
+ err = TRUE;
+ }
+
+ if (err) {
+ 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)
+ return -1;
+
+ if (move_file(tmp_file, file, TRUE) < 0) {
+ g_warning("can't replace %s .\n", file);
+ unlink(tmp_file);
+ return -1;
+ }
+
+ return 0;
+}
+
gint change_file_mode_rw(FILE *fp, const gchar *file)
{
#if HAVE_FCHMOD
gint fd;
FILE *fp;
- tmpdir = g_get_tmp_dir();
+ tmpdir = get_tmp_dir();
tmplen = strlen(tmpdir);
progname = g_get_prgname();
proglen = strlen(progname);
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 execute_async(gchar *const argv[])
{
pid_t pid;
return 0;
}
-gint execute_command_line(const gchar *cmdline)
+gint execute_sync(gchar *const argv[])
+{
+ pid_t pid;
+
+ if ((pid = fork()) < 0) {
+ perror("fork");
+ return -1;
+ }
+
+ if (pid == 0) { /* child process */
+ execvp(argv[0], argv);
+
+ perror("execvp");
+ _exit(1);
+ }
+
+ waitpid(pid, NULL, 0);
+
+ return 0;
+}
+
+gint execute_command_line(const gchar *cmdline, gboolean async)
{
gchar **argv;
- gint i;
gint ret;
argv = strsplit_with_quote(cmdline, " ", 0);
- for (i = 0; argv[i] != NULL; i++) {
- gchar *str = argv[i];
+ if (async)
+ ret = execute_async(argv);
+ else
+ ret = execute_sync(argv);
+ g_strfreev(argv);
- if (str[0] == '\'' || str[0] == '\"') {
- gint len;
+ return ret;
+}
- len = strlen(str);
- if (str[len - 1] == str[0]) {
- str[len - 1] = '\0';
- memmove(str, str + 1, len - 1);
- }
+static gint is_unchanged_uri_char(char c)
+{
+ switch (c) {
+ case '(':
+ case ')':
+ case ',':
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+void encode_uri(gchar *encoded_uri, gint bufsize, const gchar *uri)
+{
+ int i;
+ int k;
+
+ k = 0;
+ for(i = 0; i < strlen(uri) ; i++) {
+ if (is_unchanged_uri_char(uri[i])) {
+ if (k + 2 >= bufsize)
+ break;
+ encoded_uri[k++] = uri[i];
+ }
+ else {
+ char * hexa = "0123456789ABCDEF";
+
+ if (k + 4 >= bufsize)
+ break;
+ encoded_uri[k++] = '%';
+ encoded_uri[k++] = hexa[uri[i] / 16];
+ encoded_uri[k++] = hexa[uri[i] % 16];
}
}
+ encoded_uri[k] = 0;
+}
- ret = execute_async(argv);
- g_strfreev(argv);
+/* Converts two-digit hexadecimal to decimal. Used for unescaping escaped
+ * characters
+ */
+static gint axtoi(const gchar *hexstr)
+{
+ gint hi, lo, result;
+
+ hi = hexstr[0];
+ if ('0' <= hi && hi <= '9') {
+ hi -= '0';
+ } else
+ if ('a' <= hi && hi <= 'f') {
+ hi -= ('a' - 10);
+ } else
+ if ('A' <= hi && hi <= 'F') {
+ hi -= ('A' - 10);
+ }
- return ret;
+ lo = hexstr[1];
+ if ('0' <= lo && lo <= '9') {
+ lo -= '0';
+ } else
+ if ('a' <= lo && lo <= 'f') {
+ lo -= ('a'-10);
+ } else
+ if ('A' <= lo && lo <= 'F') {
+ lo -= ('A' - 10);
+ }
+ result = lo + (16 * hi);
+ return result;
+}
+
+
+/* Decodes URL-Encoded strings (i.e. strings in which spaces are replaced by
+ * plusses, and escape characters are used)
+ */
+
+void decode_uri(gchar *decoded_uri, const gchar *encoded_uri)
+{
+ const gchar *encoded;
+ gchar *decoded;
+
+ encoded = encoded_uri;
+ decoded = decoded_uri;
+
+ while (*encoded) {
+ if (*encoded == '%') {
+ encoded++;
+ if (isxdigit(encoded[0])
+ && isxdigit(encoded[1])) {
+ *decoded = (gchar) axtoi(encoded);
+ decoded++;
+ encoded += 2;
+ }
+ }
+ else if (*encoded == '+') {
+ *decoded = ' ';
+ decoded++;
+ encoded++;
+ }
+ else {
+ *decoded = *encoded;
+ decoded++;
+ encoded++;
+ }
+ }
+
+ *decoded = '\0';
}
+
gint open_uri(const gchar *uri, const gchar *cmdline)
{
static gchar *default_cmdline = "netscape -remote openURL(%s,raise)";
gchar buf[BUFFSIZE];
gchar *p;
-
+ gchar encoded_uri[BUFFSIZE];
+
g_return_val_if_fail(uri != NULL, -1);
+ /* an option to choose whether to use encode_uri or not ? */
+ encode_uri(encoded_uri, BUFFSIZE, uri);
+
if (cmdline &&
(p = strchr(cmdline, '%')) && *(p + 1) == 's' &&
!strchr(p + 2, '%'))
- g_snprintf(buf, sizeof(buf), cmdline, uri);
+ g_snprintf(buf, sizeof(buf), cmdline, encoded_uri);
else {
if (cmdline)
g_warning(_("Open URI command line is invalid: `%s'"),
cmdline);
- g_snprintf(buf, sizeof(buf), default_cmdline, uri);
+ g_snprintf(buf, sizeof(buf), default_cmdline, encoded_uri);
}
-
- execute_command_line(buf);
+
+ execute_command_line(buf, TRUE);
return 0;
}
gchar *p;
gchar c;
gint iustz;
- gint h, m;
+ gint offset;
time_t remoteoffset;
strncpy(zone3, zone, 3);
zone3[3] = '\0';
remoteoffset = 0;
- if (sscanf(zone, "%c%2d%2d", &c, &h, &m) == 3 &&
+ if (sscanf(zone, "%c%d", &c, &offset) == 2 &&
(c == '+' || c == '-')) {
- remoteoffset = ((h * 60) + m) * 60;
+ remoteoffset = ((offset / 100) * 60 + (offset % 100)) * 60;
if (c == '-')
remoteoffset = -remoteoffset;
} else if (!strncmp(zone, "UT" , 2) ||
void set_log_file(const gchar *filename)
{
if (log_fp) return;
- log_fp = fopen(filename, "w");
+ log_fp = fopen(filename, "wb");
if (!log_fp)
FILE_OP_ERROR(filename, "fopen");
}
}
}
-void debug_print(const gchar *format, ...)
+static guint log_verbosity_count = 0;
+
+void log_verbosity_set(gboolean verbose)
+{
+ if (verbose)
+ log_verbosity_count++;
+ else if (log_verbosity_count > 0)
+ log_verbosity_count--;
+}
+
+void debug_print_real(const gchar *format, ...)
{
va_list args;
gchar buf[BUFFSIZE];
fputs(buf, stdout);
}
+#define TIME_LEN 11
+
void log_print(const gchar *format, ...)
{
va_list args;
- gchar buf[BUFFSIZE];
+ 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, sizeof(buf), format, args);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
va_end(args);
if (debug_mode) fputs(buf, stdout);
fputs(buf, log_fp);
fflush(log_fp);
}
- statusbar_puts_all(buf);
+ if (log_verbosity_count)
+ statusbar_puts_all(buf + TIME_LEN);
}
void log_message(const gchar *format, ...)
{
va_list args;
- gchar buf[BUFFSIZE];
+ 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, sizeof(buf), format, args);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
va_end(args);
- if (debug_mode) g_message("%s", buf);
- log_window_append(buf, LOG_MSG);
+ if (debug_mode) g_message("%s", buf + TIME_LEN);
+ log_window_append(buf + TIME_LEN, LOG_MSG);
if (log_fp) {
- fputs("message: ", log_fp);
- fputs(buf, log_fp);
+ fwrite(buf, TIME_LEN, 1, log_fp);
+ fputs("* message: ", log_fp);
+ fputs(buf + TIME_LEN, log_fp);
fflush(log_fp);
}
+ statusbar_puts_all(buf + TIME_LEN);
}
void log_warning(const gchar *format, ...)
{
va_list args;
- gchar buf[BUFFSIZE];
+ 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, sizeof(buf), format, args);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
va_end(args);
g_warning("%s", buf);
- log_window_append(buf, LOG_WARN);
+ log_window_append(buf + TIME_LEN, LOG_WARN);
if (log_fp) {
- fputs("*** warning: ", log_fp);
- fputs(buf, 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];
+ 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, sizeof(buf), format, args);
+ g_vsnprintf(buf + TIME_LEN, BUFFSIZE, format, args);
va_end(args);
g_warning("%s", buf);
- log_window_append(buf, LOG_ERROR);
+ log_window_append(buf + TIME_LEN, LOG_ERROR);
+ if (log_fp) {
+ fwrite(buf, TIME_LEN, 1, log_fp);
+ fputs("*** error: ", log_fp);
+ fputs(buf + TIME_LEN, log_fp);
+ fflush(log_fp);
+ }
+}
+
+
+void * subject_table_lookup(GHashTable *subject_table, gchar * subject)
+{
+ if (subject == NULL)
+ subject = "";
+
+ if (g_strncasecmp(subject, "Re: ", 4) == 0)
+ return g_hash_table_lookup(subject_table, subject + 4);
+ else
+ return g_hash_table_lookup(subject_table, subject);
+}
+
+void subject_table_insert(GHashTable *subject_table, gchar * subject,
+ void * data)
+{
+ if (subject == NULL)
+ return;
+ if (* subject == 0)
+ return;
+ if (g_strcasecmp(subject, "Re:") == 0)
+ return;
+ if (g_strcasecmp(subject, "Re: ") == 0)
+ return;
+
+ if (g_strncasecmp(subject, "Re: ", 4) == 0)
+ g_hash_table_insert(subject_table, subject + 4, data);
+ else
+ g_hash_table_insert(subject_table, subject, data);
+}
+
+void subject_table_remove(GHashTable *subject_table, gchar * subject)
+{
+ if (subject == NULL)
+ return;
+
+ if (g_strncasecmp(subject, "Re: ", 4) == 0)
+ g_hash_table_remove(subject_table, subject + 4);
+ else
+ g_hash_table_remove(subject_table, subject);
+}
+
+gboolean subject_is_reply(const gchar *subject)
+{
+ /* XXX: just simply here so someone can handle really
+ * advanced Re: detection like "Re[4]", "ANTW:" or
+ * Re: Re: Re: Re: Re: Re: Re: Re:" stuff. */
+ if (subject == NULL) return FALSE;
+ else return 0 == g_strncasecmp(subject, "Re: ", 4);
+}
+
+FILE *get_tmpfile_in_dir(const gchar *dir, gchar **filename)
+{
+ int fd;
+
+ *filename = g_strdup_printf("%s%csylpheed.XXXXXX", dir, G_DIR_SEPARATOR);
+ fd = mkstemp(*filename);
+
+ return fdopen(fd, "w+");
}