/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2006 Hiroyuki Yamamoto & The Sylpheed-Claws Team
+ * Copyright (C) 1999-2009 Hiroyuki Yamamoto & The Claws Mail Team
*
* 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
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
*/
#ifdef HAVE_CONFIG_H
#include <string.h>
#include <ctype.h>
#include <errno.h>
+#include <sys/param.h>
#if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
# include <wchar.h>
#include <sys/utsname.h>
#endif
+#include <fcntl.h>
+
#ifdef G_OS_WIN32
# include <direct.h>
# include <io.h>
-# include <fcntl.h>
+# include <w32lib.h>
+#endif
+
+#ifdef MAEMO
+#include <libosso.h>
+#ifdef CHINOOK
+# include <tablet-browser-interface.h>
+#else
+# include <osso-browser-interface.h>
+#endif
#endif
#include "utils.h"
static GSList *tempfiles=NULL;
#endif
+/* Return true if we are running as root. This function should beused
+ instead of getuid () == 0. */
+gboolean superuser_p (void)
+{
+#ifdef G_OS_WIN32
+ return w32_is_administrator ();
+#else
+ return !getuid();
+#endif
+}
+
+
#if !GLIB_CHECK_VERSION(2, 7, 0) && !defined(G_OS_UNIX)
gint g_chdir(const gchar *path)
return chmod(path, mode);
#endif
}
+
+FILE* g_fopen(const gchar *filename, const gchar *mode)
+{
+#ifdef G_OS_WIN32
+ char *name = g_win32_locale_filename_from_utf8(filename);
+ FILE* fp = fopen(name, mode);
+ g_free(name);
+ return fp;
+#else
+ return fopen(filename, mode);
+#endif
+}
+int g_open(const gchar *filename, int flags, int mode)
+{
+#ifdef G_OS_WIN32
+ char *name = g_win32_locale_filename_from_utf8(filename);
+ int fd = open(name, flags, mode);
+ g_free(name);
+ return fp;
+#else
+ return open(filename, flags, mode);
+#endif
+}
#endif /* GLIB_CHECK_VERSION && G_OS_UNIX */
#ifdef G_OS_WIN32
-gint mkstemp_name(const gchar *template, gchar **name_used)
+gint mkstemp_name(gchar *template, gchar **name_used)
{
static gulong count=0; /* W32-_mktemp only supports up to 27
tempfiles... */
int tmpfd;
*name_used = g_strdup_printf("%s.%ld",_mktemp(template),count++);
- tmpfd = open (*name_used, (O_CREAT | O_RDWR | O_BINARY),
+ tmpfd = g_open (*name_used, (O_CREAT | O_RDWR | O_BINARY),
(S_IRUSR | S_IWUSR));
tempfiles=g_slist_append(tempfiles, g_strdup(*name_used));
#endif /* G_OS_WIN32 */
#ifdef G_OS_WIN32
-gint mkstemp(const gchar *template)
+gint mkstemp(gchar *template)
{
gchar *dummyname;
gint res = mkstemp_name(template, &dummyname);
}
}
-GSList *slist_concat_unique (GSList *first, GSList *second)
-{
- GSList *tmp, *ret;
- if (first == NULL) {
- if (second == NULL)
- return NULL;
- else
- return second;
- } else if (second == NULL)
- return first;
- ret = first;
- for (tmp = second; tmp != NULL; tmp = g_slist_next(tmp)) {
- if (g_slist_find(ret, tmp->data) == NULL)
- ret = g_slist_prepend(ret, tmp->data);
- }
- return ret;
-}
-
static void hash_free_strings_func(gpointer key, gpointer value, gpointer data)
{
g_free(key);
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;
gint i;
gchar *str;
- g_return_if_fail(array != NULL);
+ cm_return_if_fail(array != NULL);
for (i = 0; i < array->len; i++) {
str = g_ptr_array_index(array, i);
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;
d = (d*100) >> divisor; \
}
-gchar *to_human_readable(off_t size)
+
+/*!
+ * \brief Convert a given size in bytes in a human-readable string
+ *
+ * \param size The size expressed in bytes to convert in string
+ * \return The string that respresents the size in an human-readable way
+ */
+gchar *to_human_readable(goffset size)
{
static gchar str[14];
static gchar *b_format = NULL, *kb_format = NULL,
gb_format = _("%.2fGB");
}
- if (size < 1024) {
+ if (size < (goffset)1024) {
g_snprintf(str, sizeof(str), b_format, (gint)size);
return str;
- } else if (size >> 10 < 1024) {
+ } else if (size >> 10 < (goffset)1024) {
divide(size, 10, t, r);
g_snprintf(str, sizeof(str), kb_format, t, r);
return str;
- } else if (size >> 20 < 1024) {
+ } else if (size >> 20 < (goffset)1024) {
divide(size, 20, t, r);
g_snprintf(str, sizeof(str), mb_format, t, r);
return str;
} else {
- g_snprintf(str, sizeof(str), gb_format, (gfloat)size / (1 << 30));
+ g_snprintf(str, sizeof(str), gb_format, (gfloat)(size >> 30));
return str;
}
}
return str;
}
-void file_strip_crs(const gchar *file)
+gint file_strip_crs(const gchar *file)
{
FILE *fp = NULL, *outfp = NULL;
gchar buf[4096];
if (file == NULL)
goto freeout;
- fp = fopen(file, "rb");
+ fp = g_fopen(file, "rb");
if (!fp)
goto freeout;
- outfp = fopen(out, "wb");
+ outfp = g_fopen(out, "wb");
if (!outfp) {
fclose(fp);
goto freeout;
while (fgets(buf, sizeof (buf), fp) != NULL) {
strcrchomp(buf);
- fputs(buf, outfp);
+ if (fputs(buf, outfp) == EOF) {
+ fclose(fp);
+ fclose(outfp);
+ goto unlinkout;
+ }
}
fclose(fp);
- fclose(outfp);
- rename_force(out, file);
+ if (fclose(outfp) == EOF) {
+ goto unlinkout;
+ }
+
+ if (move_file(out, file, TRUE) < 0)
+ goto unlinkout;
+
+ g_free(out);
+ return 0;
+unlinkout:
+ claws_unlink(out);
freeout:
g_free(out);
+ return -1;
}
/* Similar to `strstr' but this function ignores the case of both strings. */
const gchar *haystack_ = (const gchar *)haystack;
const gchar *needle_ = (const gchar *)needle;
const gchar *haystack_cur = (const gchar *)haystack;
+ size_t haystack_left = haystacklen;
if (needlelen == 1)
return memchr(haystack_, *needle_, haystacklen);
- while ((haystack_cur = memchr(haystack_cur, *needle_, haystacklen))
+ while ((haystack_cur = memchr(haystack_cur, *needle_, haystack_left))
!= NULL) {
if (haystacklen - (haystack_cur - haystack_) < needlelen)
break;
if (memcmp(haystack_cur + 1, needle_ + 1, needlelen - 1) == 0)
return (gpointer)haystack_cur;
- else
+ else{
haystack_cur++;
+ haystack_left = haystacklen - (haystack_cur - haystack_);
+ }
}
return NULL;
return len;
}
+static void trim_subject_for_compare(gchar *str)
+{
+ gchar *srcp;
+
+ eliminate_parenthesis(str, '[', ']');
+ eliminate_parenthesis(str, '(', ')');
+ g_strstrip(str);
+
+ srcp = str + subject_get_prefix_length(str);
+ if (srcp != str)
+ memmove(str, srcp, strlen(srcp) + 1);
+}
+
+static void trim_subject_for_sort(gchar *str)
+{
+ gchar *srcp;
+
+ g_strstrip(str);
+
+ srcp = str + subject_get_prefix_length(str);
+ if (srcp != str)
+ memmove(str, srcp, strlen(srcp) + 1);
+}
+
/* compare subjects */
gint subject_compare(const gchar *s1, const gchar *s2)
{
return g_utf8_collate(str1, str2);
}
-void trim_subject_for_compare(gchar *str)
-{
- gchar *srcp;
-
- eliminate_parenthesis(str, '[', ']');
- eliminate_parenthesis(str, '(', ')');
- g_strstrip(str);
-
- srcp = str + subject_get_prefix_length(str);
- if (srcp != str)
- memmove(str, srcp, strlen(srcp) + 1);
-}
-
-void trim_subject_for_sort(gchar *str)
-{
- gchar *srcp;
-
- g_strstrip(str);
-
- srcp = str + subject_get_prefix_length(str);
- if (srcp != str)
- memmove(str, srcp, strlen(srcp) + 1);
-}
-
void trim_subject(gchar *str)
{
register gchar *srcp;
*destp = '\0';
}
-void extract_parenthesis_with_skip_quote(gchar *str, gchar quote_chr,
+static void extract_parenthesis_with_skip_quote(gchar *str, gchar quote_chr,
gchar op, gchar cl)
{
register gchar *srcp, *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;
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);
{
GList *old;
- g_return_val_if_fail(str != NULL, list);
+ cm_return_val_if_fail(str != NULL, list);
old = g_list_find_custom(list, (gpointer)str, (GCompareFunc)strcmp2);
if (old) {
subst_chars(str, " \"'|&;()<>'!{}[]",'_');
}
-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;
return TRUE;
}
+static const gchar * line_has_quote_char_last(const gchar * str, const gchar *quote_chars)
+{
+ gchar * position = NULL;
+ gchar * tmp_pos = NULL;
+ int i;
+
+ if (quote_chars == NULL)
+ return NULL;
+
+ 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 position;
+}
+
gint get_quote_level(const gchar *str, const gchar *quote_chars)
{
const gchar *first_pos;
if (strchr(quote_chars, *p))
quote_level++;
else if (*p != '-' && !g_ascii_isspace(*p) && p <= last_pos) {
- /* any characters are allowed except '-' and space */
- while (*p != '-'
+ /* any characters are allowed except '-','<' and space */
+ while (*p != '-' && *p != '<'
&& !strchr(quote_chars, *p)
&& !g_ascii_isspace(*p)
&& p < last_pos)
return position;
}
-const gchar * line_has_quote_char_last(const gchar * str, const gchar *quote_chars)
-{
- gchar * position = NULL;
- gchar * tmp_pos = NULL;
- int i;
-
- 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 position;
-}
-
-gchar *strstr_with_skip_quote(const gchar *haystack, const gchar *needle)
+static gchar *strstr_with_skip_quote(const gchar *haystack, const gchar *needle)
{
register guint haystack_len, needle_len;
gboolean in_squote = FALSE, in_dquote = FALSE;
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)
{
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);
+ cm_return_val_if_fail(str != NULL, NULL);
+ cm_return_val_if_fail(delim != NULL, NULL);
if (max_tokens < 1)
max_tokens = G_MAXINT;
const gchar *p = group;
const gchar *last;
- g_return_val_if_fail(group != NULL, NULL);
+ cm_return_val_if_fail(group != NULL, NULL);
last = group + strlen(group);
abbrev_group = ap = g_malloc(strlen(group) + 1);
* g_filename_from_uri() rejects escaped/locale encoded uri
* string which come from Nautilus.
*/
+#ifndef G_OS_WIN32
if (g_utf8_validate(file, -1, NULL))
locale_file
= conv_codeset_strdup(
conv_get_locale_charset_str());
if (!locale_file)
locale_file = g_strdup(file + 5);
+#else
+ locale_file = g_filename_from_uri(file, NULL, NULL);
+#endif
result = g_list_append(result, locale_file);
}
}
/* 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)
+void decode_uri_with_plus(gchar *decoded_uri, const gchar *encoded_uri, gboolean with_plus)
{
gchar *dec = decoded_uri;
const gchar *enc = encoded_uri;
enc += 2;
}
} else {
- if (*enc == '+')
+ if (with_plus && *enc == '+')
*dec = ' ';
else
*dec = *enc;
*dec = '\0';
}
-gint scan_mailto_url(const gchar *mailto, gchar **to, gchar **cc, gchar **bcc,
- gchar **subject, gchar **body)
+void decode_uri(gchar *decoded_uri, const gchar *encoded_uri)
+{
+ decode_uri_with_plus(decoded_uri, encoded_uri, TRUE);
+}
+
+static gchar *decode_uri_gdup(const gchar *encoded_uri)
+{
+ gchar *buffer = g_malloc(strlen(encoded_uri)+1);
+ decode_uri_with_plus(buffer, encoded_uri, FALSE);
+ return buffer;
+}
+
+gint scan_mailto_url(const gchar *mailto, gchar **from, gchar **to, gchar **cc, gchar **bcc,
+ gchar **subject, gchar **body, gchar ***attach, gchar **inreplyto)
{
gchar *tmp_mailto;
gchar *p;
+ const gchar *forbidden_uris[] = { ".gnupg/",
+ "/etc/passwd",
+ "/etc/shadow",
+ ".ssh/",
+ "../",
+ NULL };
+ gint num_attach = 0;
+ gchar **my_att = NULL;
Xstrdup_a(tmp_mailto, mailto, return -1);
}
if (to && !*to)
- *to = g_strdup(tmp_mailto);
+ *to = decode_uri_gdup(tmp_mailto);
+
+ my_att = g_malloc(sizeof(char *));
+ my_att[0] = NULL;
while (p) {
gchar *field, *value;
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);
+ if (from && !g_ascii_strcasecmp(field, "from")) {
+ if (!*from) {
+ *from = decode_uri_gdup(value);
+ } else {
+ gchar *tmp = decode_uri_gdup(value);
+ gchar *new_from = g_strdup_printf("%s, %s", *from, tmp);
+ g_free(*from);
+ *from = new_from;
+ }
+ } else if (cc && !g_ascii_strcasecmp(field, "cc")) {
+ if (!*cc) {
+ *cc = decode_uri_gdup(value);
+ } else {
+ gchar *tmp = decode_uri_gdup(value);
+ gchar *new_cc = g_strdup_printf("%s, %s", *cc, tmp);
+ g_free(*cc);
+ *cc = new_cc;
+ }
+ } else if (bcc && !g_ascii_strcasecmp(field, "bcc")) {
+ if (!*bcc) {
+ *bcc = decode_uri_gdup(value);
+ } else {
+ gchar *tmp = decode_uri_gdup(value);
+ gchar *new_bcc = g_strdup_printf("%s, %s", *bcc, tmp);
+ g_free(*bcc);
+ *bcc = new_bcc;
+ }
} else if (subject && !*subject &&
!g_ascii_strcasecmp(field, "subject")) {
- *subject = g_malloc(strlen(value) + 1);
- decode_uri(*subject, value);
+ *subject = decode_uri_gdup(value);
} else if (body && !*body && !g_ascii_strcasecmp(field, "body")) {
- *body = g_malloc(strlen(value) + 1);
- decode_uri(*body, value);
+ *body = decode_uri_gdup(value);
+ } else if (body && !*body && !g_ascii_strcasecmp(field, "insert")) {
+ gchar *tmp = decode_uri_gdup(value);
+ if (!g_file_get_contents(tmp, body, NULL, NULL)) {
+ g_warning("Error: couldn't set insert file '%s' in body\n", value);
+ }
+ g_free(tmp);
+ tmp = NULL;
+ } else if (attach && !g_ascii_strcasecmp(field, "attach")) {
+ int i = 0;
+ gchar *tmp = decode_uri_gdup(value);
+ for (; forbidden_uris[i]; i++) {
+ if (strstr(tmp, forbidden_uris[i])) {
+ g_print("Refusing to attach '%s', potential private data leak\n",
+ tmp);
+ g_free(tmp);
+ tmp = NULL;
+ break;
+ }
+ }
+ if (tmp) {
+ /* attach is correct */
+ num_attach++;
+ my_att = g_realloc(my_att, (sizeof(char *))*(num_attach+1));
+ my_att[num_attach-1] = tmp;
+ my_att[num_attach] = NULL;
+ }
+ } else if (inreplyto && !*inreplyto &&
+ !g_ascii_strcasecmp(field, "in-reply-to")) {
+ *inreplyto = decode_uri_gdup(value);
}
}
+ if (attach)
+ *attach = my_att;
return 0;
}
handle = dlopen (dllnames[i], RTLD_LAZY);
if (handle)
{
- func = dlsym (handle, "SHGetFolderPathA");
+ func = dlsym (handle, "SHGetFolderPathW");
if (!func)
{
dlclose (handle);
const gchar *get_home_dir(void)
{
#ifdef G_OS_WIN32
- static char home_dir[MAX_PATH] = "";
-
- if (home_dir[0] == '\0') {
+ static char home_dir_utf16[MAX_PATH] = "";
+ static gchar *home_dir_utf8 = NULL;
+ if (home_dir_utf16[0] == '\0') {
if (w32_shgetfolderpath
(NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
- NULL, 0, home_dir) < 0)
- strcpy (home_dir, "C:\\Sylpheed");
+ NULL, 0, home_dir_utf16) < 0)
+ strcpy (home_dir_utf16, "C:\\Sylpheed");
+ home_dir_utf8 = g_utf16_to_utf8 ((const gunichar *)home_dir_utf16, -1, NULL, NULL, NULL);
}
- return home_dir;
+ return home_dir_utf8;
#else
static const gchar *homeenv = NULL;
#endif
}
+static gchar *claws_rc_dir = NULL;
+static gboolean rc_dir_alt = FALSE;
const gchar *get_rc_dir(void)
{
- static gchar *rc_dir = NULL;
- if (!rc_dir)
- rc_dir = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
+ if (!claws_rc_dir)
+ claws_rc_dir = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
RC_DIR, NULL);
- return rc_dir;
+ return claws_rc_dir;
}
-const gchar *get_mail_base_dir(void)
+void set_rc_dir(const gchar *dir)
{
-#ifdef G_OS_WIN32
- static gchar *mail_base_dir = NULL;
+ if (claws_rc_dir != NULL) {
+ g_print("Error: rc_dir already set\n");
+ } else {
+ rc_dir_alt = TRUE;
+ if (g_path_is_absolute(dir))
+ claws_rc_dir = g_strdup(dir);
+ else {
+ claws_rc_dir = g_strconcat(g_get_current_dir(),
+ G_DIR_SEPARATOR_S, dir, NULL);
+ }
+ debug_print("set rc_dir to %s\n", claws_rc_dir);
+ if (!is_dir_exist(claws_rc_dir)) {
+ if (make_dir_hier(claws_rc_dir) != 0) {
+ g_print("Error: can't create %s\n",
+ claws_rc_dir);
+ }
+ }
+ }
+}
- if (!mail_base_dir)
- mail_base_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
- "Mailboxes", NULL);
+gboolean rc_dir_is_alt(void) {
+ return rc_dir_alt;
+}
- return mail_base_dir;
-#else
+const gchar *get_mail_base_dir(void)
+{
return get_home_dir();
-#endif
}
+#ifdef MAEMO
+const gchar *prefs_common_get_data_root(void);
+gchar *last_data_root = NULL;
+#endif
+
const gchar *get_news_cache_dir(void)
{
static gchar *news_cache_dir = NULL;
-
+#ifdef MAEMO
+ const gchar *data_root = prefs_common_get_data_root();
+ if (strcmp2(data_root, last_data_root)) {
+ g_free(news_cache_dir);
+ news_cache_dir = NULL;
+ }
+#endif
if (!news_cache_dir)
+#ifndef MAEMO
news_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
NEWS_CACHE_DIR, NULL);
-
+#else
+ {
+ if (data_root) {
+ news_cache_dir = g_strconcat(data_root, G_DIR_SEPARATOR_S,
+ "Claws", G_DIR_SEPARATOR_S,
+ g_get_user_name(), G_DIR_SEPARATOR_S,
+ NEWS_CACHE_DIR, NULL);
+ g_free(last_data_root);
+ last_data_root = g_strdup(last_data_root);
+ } else {
+ news_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ NEWS_CACHE_DIR, NULL);
+ g_free(last_data_root);
+ last_data_root = NULL;
+ }
+ }
+#endif
return news_cache_dir;
}
const gchar *get_imap_cache_dir(void)
{
static gchar *imap_cache_dir = NULL;
+#ifdef MAEMO
+ const gchar *data_root = prefs_common_get_data_root();
+ if (strcmp2(data_root, last_data_root)) {
+ g_free(imap_cache_dir);
+ imap_cache_dir = NULL;
+ }
+#endif
if (!imap_cache_dir)
+#ifndef MAEMO
imap_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
IMAP_CACHE_DIR, NULL);
+#else
+ {
+ if (data_root) {
+ imap_cache_dir = g_strconcat(data_root, G_DIR_SEPARATOR_S,
+ "Claws", G_DIR_SEPARATOR_S,
+ g_get_user_name(), G_DIR_SEPARATOR_S,
+ IMAP_CACHE_DIR, NULL);
+ g_free(last_data_root);
+ last_data_root = g_strdup(last_data_root);
+ } else {
+ imap_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ IMAP_CACHE_DIR, NULL);
+ g_free(last_data_root);
+ last_data_root = NULL;
+ }
+ }
+#endif
return imap_cache_dir;
}
-const gchar *get_mbox_cache_dir(void)
-{
- static gchar *mbox_cache_dir = NULL;
-
- if (!mbox_cache_dir)
- mbox_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
- MBOX_CACHE_DIR, NULL);
-
- return mbox_cache_dir;
-}
-
const gchar *get_mime_tmp_dir(void)
{
static gchar *mime_tmp_dir = NULL;
return template_dir;
}
-const gchar *get_header_cache_dir(void)
+#ifdef G_OS_WIN32
+const gchar *get_cert_file(void)
{
- static gchar *header_dir = NULL;
-
- if (!header_dir)
- header_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
- HEADER_CACHE_DIR, NULL);
+ const gchar *cert_file = NULL;
+ if (!cert_file)
+ cert_file = g_strconcat(w32_get_module_dir(),
+ "\\share\\claws-mail\\",
+ "ca-certificates.crt",
+ NULL);
+ return cert_file;
+}
+#endif
- return header_dir;
+/* Return the filepath of the claws-mail.desktop file */
+const gchar *get_desktop_file(void)
+{
+#ifdef DESKTOPFILEPATH
+ return DESKTOPFILEPATH;
+#else
+ return NULL;
+#endif
}
/* Return the default directory for Plugins. */
if (!plugin_dir)
plugin_dir = g_strconcat(w32_get_module_dir(),
- "\\lib\\sylpheed-claws\\plugins\\",
+ "\\lib\\claws-mail\\plugins\\",
NULL);
return plugin_dir;
#else
#endif
}
+
+#ifdef G_OS_WIN32
+/* Return the default directory for Themes. */
+const gchar *get_themes_dir(void)
+{
+ static gchar *themes_dir = NULL;
+
+ if (!themes_dir)
+ themes_dir = g_strconcat(w32_get_module_dir(),
+ "\\share\\claws-mail\\themes",
+ NULL);
+ return themes_dir;
+}
+#endif
+
const gchar *get_tmp_dir(void)
{
static gchar *tmp_dir = NULL;
if (!domain_name) {
struct hostent *hp;
- struct utsname uts;
+ char hostname[256];
- if (uname(&uts) < 0) {
- perror("uname");
+ if (gethostname(hostname, sizeof(hostname)) != 0) {
+ perror("gethostname");
domain_name = "unknown";
} else {
- if ((hp = my_gethostbyname(uts.nodename)) == NULL) {
+ hostname[sizeof(hostname) - 1] = '\0';
+ if ((hp = my_gethostbyname(hostname)) == NULL) {
perror("gethostbyname");
- domain_name = g_strdup(uts.nodename);
+ domain_name = g_strdup(hostname);
} else {
domain_name = g_strdup(hp->h_name);
}
}
-
debug_print("domain name = %s\n", domain_name);
}
return s.st_size;
}
+time_t get_file_mtime(const gchar *file)
+{
+ struct stat s;
+
+ if (g_stat(file, &s) < 0) {
+ FILE_OP_ERROR(file, "stat");
+ return -1;
+ }
+
+ return s.st_mtime;
+}
+
off_t get_file_size_as_crlf(const gchar *file)
{
FILE *fp;
gchar buf[BUFFSIZE];
if ((fp = g_fopen(file, "rb")) == NULL) {
- FILE_OP_ERROR(file, "fopen");
+ FILE_OP_ERROR(file, "g_fopen");
return -1;
}
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;
gboolean dirent_is_regular_file(struct dirent *d)
{
-#ifdef HAVE_DIRENT_D_TYPE
+#if !defined(G_OS_WIN32) && !defined(MAEMO) && defined(HAVE_DIRENT_D_TYPE)
if (d->d_type == DT_REG)
return TRUE;
else if (d->d_type != DT_UNKNOWN)
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;
}
while ((dir_name = g_dir_read_name(dp)) != NULL) {
- if (g_unlink(dir_name) < 0)
+ if (claws_unlink(dir_name) < 0)
FILE_OP_ERROR(dir_name, "unlink");
}
if (file_no > 0 && first <= file_no && file_no <= last) {
if (is_dir_exist(dir_name))
continue;
- if (g_unlink(dir_name) < 0)
+ if (claws_unlink(dir_name) < 0)
FILE_OP_ERROR(dir_name, "unlink");
}
}
debug_print("removing unwanted file %d from %s\n", file_no, dir);
if (is_dir_exist(dir_name))
continue;
- if (g_unlink(dir_name) < 0)
+ if (claws_unlink(dir_name) < 0)
FILE_OP_ERROR(dir_name, "unlink");
}
}
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;
-}
-
gint remove_dir_recursive(const gchar *dir)
{
struct stat s;
}
if (!S_ISDIR(s.st_mode)) {
- if (g_unlink(dir) < 0) {
+ if (claws_unlink(dir) < 0) {
FILE_OP_ERROR(dir, "unlink");
return -1;
}
return -1;
}
} else {
- if (g_unlink(dir_name) < 0)
+ if (claws_unlink(dir_name) < 0)
FILE_OP_ERROR(dir_name, "unlink");
}
}
return -1;
}
if (is_file_exist(newpath)) {
- if (g_unlink(newpath) < 0)
+ if (claws_unlink(newpath) < 0)
FILE_OP_ERROR(newpath, "unlink");
}
#endif
gboolean err = FALSE;
if ((src_fp = g_fopen(src, "rb")) == NULL) {
- FILE_OP_ERROR(src, "fopen");
+ FILE_OP_ERROR(src, "g_fopen");
return -1;
}
if ((dest_fp = g_fopen(dest, "ab")) == NULL) {
- FILE_OP_ERROR(dest, "fopen");
+ FILE_OP_ERROR(dest, "g_fopen");
fclose(src_fp);
return -1;
}
g_warning("writing to %s failed.\n", dest);
fclose(dest_fp);
fclose(src_fp);
- g_unlink(dest);
+ claws_unlink(dest);
return -1;
}
}
}
if (err) {
- g_unlink(dest);
+ claws_unlink(dest);
return -1;
}
gboolean err = FALSE;
if ((src_fp = g_fopen(src, "rb")) == NULL) {
- FILE_OP_ERROR(src, "fopen");
+ FILE_OP_ERROR(src, "g_fopen");
return -1;
}
if (is_file_exist(dest)) {
}
if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
- FILE_OP_ERROR(dest, "fopen");
+ FILE_OP_ERROR(dest, "g_fopen");
fclose(src_fp);
if (dest_bak) {
if (rename_force(dest_bak, dest) < 0)
g_warning("writing to %s failed.\n", dest);
fclose(dest_fp);
fclose(src_fp);
- g_unlink(dest);
+ claws_unlink(dest);
if (dest_bak) {
if (rename_force(dest_bak, dest) < 0)
FILE_OP_ERROR(dest_bak, "rename");
}
if (err) {
- g_unlink(dest);
+ claws_unlink(dest);
if (dest_bak) {
if (rename_force(dest_bak, dest) < 0)
FILE_OP_ERROR(dest_bak, "rename");
}
if (keep_backup == FALSE && dest_bak)
- g_unlink(dest_bak);
+ claws_unlink(dest_bak);
g_free(dest_bak);
if (copy_file(src, dest, FALSE) < 0) return -1;
- g_unlink(src);
+ claws_unlink(src);
return 0;
}
gboolean err = FALSE;
if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
- FILE_OP_ERROR(dest, "fopen");
+ FILE_OP_ERROR(dest, "g_fopen");
return -1;
}
if (err) {
g_warning("writing to %s failed.\n", dest);
- g_unlink(dest);
+ claws_unlink(dest);
return -1;
}
{
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, 1, len - 1, dest_fp);
- if (r != (len -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];
+ gint len;
gboolean err = FALSE;
+ gboolean last_linebreak = FALSE;
+
+ if (src == NULL || dest == NULL)
+ return -1;
if ((src_fp = g_fopen(src, "rb")) == NULL) {
- FILE_OP_ERROR(src, "fopen");
+ FILE_OP_ERROR(src, "g_fopen");
return -1;
}
if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
- FILE_OP_ERROR(dest, "fopen");
+ FILE_OP_ERROR(dest, "g_fopen");
fclose(src_fp);
return -1;
}
}
while (fgets(buf, sizeof(buf), src_fp) != NULL) {
- strcrchomp(buf);
- if (fputs(buf, dest_fp) == EOF) {
+ 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, 1, len - 1, dest_fp);
+ if (r != (len -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);
+ claws_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;
}
if (err) {
- g_unlink(dest);
+ claws_unlink(dest);
return -1;
}
return 0;
}
-gint uncanonicalize_file_replace(const gchar *file)
+gint canonicalize_file_replace(const gchar *file)
{
gchar *tmp_file;
tmp_file = get_tmp_file();
- if (uncanonicalize_file(file, tmp_file) < 0) {
+ 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);
+ claws_unlink(tmp_file);
g_free(tmp_file);
return -1;
}
buf_uniq[i] = tbl[g_random_int_range(0, sizeof(tbl) - 1)];
buf_uniq[i] = '\0';
- return g_strdup_printf("%s_%s", prefix ? prefix : "MP",
+ return g_strdup_printf("%s_/%s", prefix ? prefix : "MP",
buf_uniq);
}
gchar *fname;
gint fd;
FILE *fp;
+#ifndef G_OS_WIN32
gchar buf[2]="\0";
+#endif
tmpdir = get_tmp_dir();
tmplen = strlen(tmpdir);
progname = g_get_prgname();
if (progname == NULL)
- progname = "sylpheed-claws";
+ progname = "claws-mail";
proglen = strlen(progname);
Xalloca(fname, tmplen + 1 + proglen + sizeof(suffix),
return tmpfile());
return tmpfile();
#ifndef G_OS_WIN32
- g_unlink(fname);
+ claws_unlink(fname);
/* verify that we can write in the file after unlinking */
if (write(fd, buf, 1) < 0) {
{
int fd;
#ifdef G_OS_WIN32
- char *template = g_strdup_printf ("%s%csylpheed.XXXXXX",
+ char *template = g_strdup_printf ("%s%cclaws.XXXXXX",
dir, G_DIR_SEPARATOR);
fd = mkstemp_name(template, filename);
g_free(template);
#else
- *filename = g_strdup_printf("%s%csylpheed.XXXXXX", dir, G_DIR_SEPARATOR);
+ *filename = g_strdup_printf("%s%cclaws.XXXXXX", dir, G_DIR_SEPARATOR);
fd = mkstemp(*filename);
#endif
return fdopen(fd, "w+");
FILE *fp;
size_t len;
- g_return_val_if_fail(str != NULL, NULL);
+ cm_return_val_if_fail(str != NULL, NULL);
fp = my_tmpfile();
if (!fp) {
FILE *fp;
size_t len;
- g_return_val_if_fail(str != NULL, -1);
- g_return_val_if_fail(file != NULL, -1);
+ cm_return_val_if_fail(str != NULL, -1);
+ cm_return_val_if_fail(file != NULL, -1);
if ((fp = g_fopen(file, "wb")) == NULL) {
- FILE_OP_ERROR(file, "fopen");
+ FILE_OP_ERROR(file, "g_fopen");
return -1;
}
if (fwrite(str, 1, len, fp) != len) {
FILE_OP_ERROR(file, "fwrite");
fclose(fp);
- g_unlink(file);
+ claws_unlink(file);
return -1;
}
if (fclose(fp) == EOF) {
FILE_OP_ERROR(file, "fclose");
- g_unlink(file);
+ claws_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)
+static gchar *file_read_stream_to_str_full(FILE *fp, gboolean recode)
{
GByteArray *array;
guchar buf[BUFSIZ];
gint n_read;
gchar *str;
- g_return_val_if_fail(fp != NULL, NULL);
+ cm_return_val_if_fail(fp != NULL, NULL);
array = g_byte_array_new();
str = (gchar *)array->data;
g_byte_array_free(array, FALSE);
- if (!g_utf8_validate(str, -1, NULL)) {
+ if (recode && !g_utf8_validate(str, -1, NULL)) {
const gchar *src_codeset, *dest_codeset;
gchar *tmp = NULL;
src_codeset = conv_get_locale_charset_str();
return str;
}
-gint execute_async(gchar *const argv[])
+static gchar *file_read_to_str_full(const gchar *file, gboolean recode)
+{
+ FILE *fp;
+ gchar *str;
+ struct stat s;
+#ifndef G_OS_WIN32
+ gint fd, err;
+ struct timeval timeout = {1, 0};
+ fd_set fds;
+ int fflags = 0;
+#endif
+
+ cm_return_val_if_fail(file != NULL, NULL);
+
+ if (g_stat(file, &s) != 0) {
+ FILE_OP_ERROR(file, "stat");
+ return NULL;
+ }
+ if (S_ISDIR(s.st_mode)) {
+ g_warning("%s: is a directory\n", file);
+ return NULL;
+ }
+
+#ifdef G_OS_WIN32
+ fp = g_fopen (file, "rb");
+ if (fp == NULL) {
+ FILE_OP_ERROR(file, "open");
+ return NULL;
+ }
+#else
+ /* test whether the file is readable without blocking */
+ fd = g_open(file, O_RDONLY | O_NONBLOCK, 0);
+ if (fd == -1) {
+ FILE_OP_ERROR(file, "open");
+ return NULL;
+ }
+
+ FD_ZERO(&fds);
+ FD_SET(fd, &fds);
+
+ /* allow for one second */
+ err = select(fd+1, &fds, NULL, NULL, &timeout);
+ if (err <= 0 || !FD_ISSET(fd, &fds)) {
+ if (err < 0) {
+ FILE_OP_ERROR(file, "select");
+ } else {
+ g_warning("%s: doesn't seem readable\n", file);
+ }
+ close(fd);
+ return NULL;
+ }
+
+ /* Now clear O_NONBLOCK */
+ if ((fflags = fcntl(fd, F_GETFL)) < 0) {
+ FILE_OP_ERROR(file, "fcntl (F_GETFL)");
+ close(fd);
+ return NULL;
+ }
+ if (fcntl(fd, F_SETFL, (fflags & ~O_NONBLOCK)) < 0) {
+ FILE_OP_ERROR(file, "fcntl (F_SETFL)");
+ close(fd);
+ return NULL;
+ }
+
+ /* get the FILE pointer */
+ fp = fdopen(fd, "rb");
+
+ if (fp == NULL) {
+ FILE_OP_ERROR(file, "fdopen");
+ close(fd); /* if fp isn't NULL, we'll use fclose instead! */
+ return NULL;
+ }
+#endif
+
+ str = file_read_stream_to_str_full(fp, recode);
+
+ fclose(fp);
+
+ return str;
+}
+
+gchar *file_read_to_str(const gchar *file)
+{
+ return file_read_to_str_full(file, TRUE);
+}
+gchar *file_read_stream_to_str(FILE *fp)
+{
+ return file_read_stream_to_str_full(fp, TRUE);
+}
+
+gchar *file_read_to_str_no_recode(const gchar *file)
+{
+ return file_read_to_str_full(file, FALSE);
+}
+gchar *file_read_stream_to_str_no_recode(FILE *fp)
+{
+ return file_read_stream_to_str_full(fp, FALSE);
+}
+
+char *fgets_crlf(char *buf, int size, FILE *stream)
+{
+ gboolean is_cr = FALSE;
+ gboolean last_was_cr = FALSE;
+ int c = 0;
+ char *cs;
+
+ cs = buf;
+ while (--size > 0 && (c = getc(stream)) != EOF)
+ {
+ *cs++ = c;
+ is_cr = (c == '\r');
+ if (c == '\n') {
+ break;
+ }
+ if (last_was_cr) {
+ *(--cs) = '\n';
+ cs++;
+ ungetc(c, stream);
+ break;
+ }
+ last_was_cr = is_cr;
+ }
+ if (c == EOF && cs == buf)
+ return NULL;
+
+ *cs = '\0';
+
+ return buf;
+}
+
+static gint execute_async(gchar *const argv[])
{
- g_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
+ cm_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) {
return 0;
}
-gint execute_sync(gchar *const argv[])
+static gint execute_sync(gchar *const argv[])
{
gint status;
- g_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
+ cm_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
+#ifdef G_OS_UNIX
if (g_spawn_sync(NULL, (gchar **)argv, NULL, G_SPAWN_SEARCH_PATH,
NULL, NULL, NULL, NULL, &status, NULL) == FALSE) {
g_warning("Couldn't execute command: %s\n", argv[0]);
return -1;
}
-#ifdef G_OS_UNIX
if (WIFEXITED(status))
return WEXITSTATUS(status);
else
return -1;
#else
+ if (g_spawn_sync(NULL, (gchar **)argv, NULL, G_SPAWN_SEARCH_PATH|
+ G_SPAWN_CHILD_INHERITS_STDIN|G_SPAWN_LEAVE_DESCRIPTORS_OPEN,
+ NULL, NULL, NULL, NULL, &status, NULL) == FALSE) {
+ g_warning("Couldn't execute command: %s\n", argv[0]);
+ return -1;
+ }
+
return status;
#endif
}
gchar **argv;
gint ret;
- debug_print("execute_command_line(): executing: %s\n", cmdline);
+ debug_print("execute_command_line(): executing: %s\n", cmdline?cmdline:"(null)");
argv = strsplit_with_quote(cmdline, " ", 0);
gchar *child_stdout;
gint status;
- g_return_val_if_fail(cmdline != NULL, NULL);
+ cm_return_val_if_fail(cmdline != NULL, NULL);
debug_print("get_command_output(): executing: %s\n", cmdline);
return child_stdout;
}
-
+#ifndef MAEMO
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)
+static void encode_uri(gchar *encoded_uri, gint bufsize, const gchar *uri)
{
int i;
int k;
}
encoded_uri[k] = 0;
}
-
+#endif
gint open_uri(const gchar *uri, const gchar *cmdline)
{
+#ifndef MAEMO
+#ifndef G_OS_WIN32
gchar buf[BUFFSIZE];
gchar *p;
gchar encoded_uri[BUFFSIZE];
-
- g_return_val_if_fail(uri != NULL, -1);
+ cm_return_val_if_fail(uri != NULL, -1);
/* an option to choose whether to use encode_uri or not ? */
encode_uri(encoded_uri, BUFFSIZE, uri);
g_snprintf(buf, sizeof(buf), cmdline, encoded_uri);
else {
if (cmdline)
- g_warning("Open URI command line is invalid "
+ g_warning("Open URI command-line is invalid "
"(there must be only one '%%s'): %s",
cmdline);
g_snprintf(buf, sizeof(buf), DEFAULT_BROWSER_CMD, encoded_uri);
}
execute_command_line(buf, TRUE);
-
+#else
+ ShellExecute(NULL, "open", uri, NULL, NULL, SW_SHOW);
+#endif
+#else
+ extern osso_context_t *get_osso_context(void);
+ osso_rpc_run_with_defaults(get_osso_context(), "osso_browser",
+ OSSO_BROWSER_OPEN_NEW_WINDOW_REQ, NULL,
+ DBUS_TYPE_STRING, uri, DBUS_TYPE_INVALID);
+#endif
return 0;
}
gchar buf[BUFFSIZE];
gchar *p;
- g_return_val_if_fail(filepath != NULL, -1);
+ cm_return_val_if_fail(filepath != NULL, -1);
if (cmdline &&
(p = strchr(cmdline, '%')) && *(p + 1) == 's' &&
g_snprintf(buf, sizeof(buf), cmdline, filepath);
else {
if (cmdline)
- g_warning("Open Text Editor command line is invalid "
+ g_warning("Open Text Editor command-line is invalid "
"(there must be only one '%%s'): %s",
cmdline);
g_snprintf(buf, sizeof(buf), DEFAULT_EDITOR_CMD, filepath);
{
struct tm gmt, *lt;
gint off;
-
- gmt = *gmtime(now);
- lt = localtime(now);
+#ifndef G_OS_WIN32
+ struct tm buf1, buf2;
+#endif
+#ifdef G_OS_WIN32
+ if (now && *now < 0)
+ return 0;
+#endif
+ gmt = *gmtime_r(now, &buf1);
+ lt = localtime_r(now, &buf2);
off = (lt->tm_hour - gmt.tm_hour) * 60 + lt->tm_min - gmt.tm_min;
struct tm gmt, *lt;
gint off;
gchar sign = '+';
-
- gmt = *gmtime(now);
- lt = localtime(now);
+#ifndef G_OS_WIN32
+ struct tm buf1, buf2;
+#endif
+#ifdef G_OS_WIN32
+ if (now && *now < 0)
+ return 0;
+#endif
+ gmt = *gmtime_r(now, &buf1);
+ lt = localtime_r(now, &buf2);
off = (lt->tm_hour - gmt.tm_hour) * 60 + lt->tm_min - gmt.tm_min;
time_t t;
gchar day[4], mon[4];
gint dd, hh, mm, ss, yyyy;
+#ifndef G_OS_WIN32
+ struct tm buf1;
+ gchar buf2[BUFFSIZE];
+#endif
t = time(NULL);
- lt = localtime(&t);
+ lt = localtime_r(&t, &buf1);
- sscanf(asctime(lt), "%3s %3s %d %d:%d:%d %d\n",
+ sscanf(asctime_r(lt, buf2), "%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);
-}
-
void debug_set_mode(gboolean mode)
{
debug_mode = mode;
g_hash_table_remove(subject_table, subject);
}
+#ifndef G_OS_WIN32
+static regex_t u_regex;
+static gboolean u_init_;
+#endif
+
+void utils_free_regex(void)
+{
+#ifndef G_OS_WIN32
+ if (u_init_) {
+ regfree(&u_regex);
+ u_init_ = FALSE;
+ }
+#endif
+}
+
/*!
*\brief Check if a string is prefixed with known (combinations)
* of prefixes. The function assumes that each prefix
*/
int subject_get_prefix_length(const gchar *subject)
{
+#ifndef G_OS_WIN32
/*!< Array with allowable reply prefixes regexps. */
static const gchar * const prefixes[] = {
"Re\\:", /* "Re:" */
"Antw\\:", /* "Antw:" (Dutch / German Outlook) */
"Aw\\:", /* "Aw:" (German) */
"Antwort\\:", /* "Antwort:" (German Lotus Notes) */
- "Res\\:", /* "Res:" (Brazilian Outlook) */
+ "Res\\:", /* "Res:" (Spanish/Brazilian Outlook) */
"Fw\\:", /* "Fw:" Forward */
+ "Fwd\\:", /* "Fwd:" Forward */
"Enc\\:", /* "Enc:" Forward (Brazilian Outlook) */
"Odp\\:", /* "Odp:" Re (Polish Outlook) */
"Rif\\:", /* "Rif:" (Italian Outlook) */
"Sv\\:", /* "Sv" (Norwegian) */
"Vs\\:", /* "Vs" (Norwegian) */
"Ad\\:", /* "Ad" (Norwegian) */
- "\347\255\224\345\244\215\\:" /* "Re" (Chinese, UTF-8) */
+ "\347\255\224\345\244\215\\:", /* "Re" (Chinese, UTF-8) */
+ "R\303\251f\\. \\:", /* "Réf. :" (French Lotus Notes) */
+ "Re \\:", /* "Re :" (French Yahoo Mail) */
/* add more */
};
const int PREFIXES = sizeof prefixes / sizeof prefixes[0];
int n;
regmatch_t pos;
- static regex_t regex;
- static gboolean init_;
if (!subject) return 0;
if (!*subject) return 0;
- if (!init_) {
+ if (!u_init_) {
GString *s = g_string_new("");
for (n = 0; n < PREFIXES; n++)
/* We now have something like "^\ *((PREFIX1\ ?)|(PREFIX2\ ?))+"
* TODO: Should this be "^\ *(((PREFIX1)|(PREFIX2))\ ?)+" ??? */
- if (regcomp(®ex, s->str, REG_EXTENDED | REG_ICASE)) {
+ if (regcomp(&u_regex, s->str, REG_EXTENDED | REG_ICASE)) {
debug_print("Error compiling regexp %s\n", s->str);
g_string_free(s, TRUE);
return 0;
} else {
- init_ = TRUE;
+ u_init_ = TRUE;
g_string_free(s, TRUE);
}
}
- if (!regexec(®ex, subject, 1, &pos, 0) && pos.rm_so != -1)
+ if (!regexec(&u_regex, subject, 1, &pos, 0) && pos.rm_so != -1)
return pos.rm_eo;
else
return 0;
-}
+#else
+ /*!< Array with allowable reply prefixes regexps. */
+ static const gchar * const prefixes[] = {
+ "re:", /* "Re:" */
+ "antw:", /* "Antw:" (Dutch / German Outlook) */
+ "aw:", /* "Aw:" (German) */
+ "antwort:", /* "Antwort:" (German Lotus Notes) */
+ "res:", /* "Res:" (Spanish/Brazilian Outlook) */
+ "fw:", /* "Fw:" Forward */
+ "fwd:", /* "Fwd:" Forward */
+ "enc:", /* "Enc:" Forward (Brazilian Outlook) */
+ "odp:", /* "Odp:" Re (Polish Outlook) */
+ "rif:", /* "Rif:" (Italian Outlook) */
+ "sv:", /* "Sv" (Norwegian) */
+ "vs:", /* "Vs" (Norwegian) */
+ "ad:", /* "Ad" (Norwegian) */
+ "R\303\251f. :", /* "Réf. :" (French Lotus Notes) */
+ "Re :", /* "Re :" (French Yahoo Mail) */
+ /* add more */
+ };
+ const int PREFIXES = sizeof prefixes / sizeof prefixes[0];
+ int n;
+
+ if (!subject) return 0;
+ if (!*subject) return 0;
-guint g_stricase_hash(gconstpointer gptr)
+ for (n = 0; n < PREFIXES; n++) {
+ int len = strlen(prefixes[n]);
+ if (!strncasecmp(subject, prefixes[n], len)) {
+ if (subject[len] == ' ')
+ return len+1;
+ else
+ return len;
+ }
+ }
+ return 0;
+#endif
+}
+static guint g_stricase_hash(gconstpointer gptr)
{
guint hash_result = 0;
const char *str;
return hash_result;
}
-gint g_stricase_equal(gconstpointer gptr1, gconstpointer gptr2)
+static gint g_stricase_equal(gconstpointer gptr1, gconstpointer gptr2)
{
const char *str1 = gptr1;
const char *str2 = gptr2;
return GPOINTER_TO_INT(a) - GPOINTER_TO_INT(b);
}
-gchar *generate_msgid(gchar *buf, gint len)
+gchar *generate_msgid(gchar *buf, gint len, gchar *user_addr)
{
struct tm *lt;
time_t t;
gchar *addr;
+#ifndef G_OS_WIN32
+ struct tm buft;
+#endif
t = time(NULL);
- lt = localtime(&t);
+ lt = localtime_r(&t, &buft);
- addr = g_strconcat("@", get_domain_name(), NULL);
+ if (strcmp(buf, "") == 0) {
+ if (user_addr != NULL) {
+ addr = g_strconcat(user_addr, "@", get_domain_name(), NULL);
+ }
+ else {
+ addr = g_strconcat("@", get_domain_name(), NULL);
+ }
+ }
+ else {
+ if (user_addr != NULL) {
+ addr = g_strconcat(user_addr, "@", buf, NULL);
+ }
+ else {
+ addr = g_strconcat("@", buf, NULL);
+ }
+ }
g_snprintf(buf, len, "%04d%02d%02d%02d%02d%02d.%08x%s",
lt->tm_year + 1900, lt->tm_mon + 1,
GNode *root;
GNodeMapData mapdata;
- g_return_val_if_fail(node != NULL, NULL);
- g_return_val_if_fail(func != NULL, NULL);
+ cm_return_val_if_fail(node != NULL, NULL);
+ cm_return_val_if_fail(func != NULL, NULL);
root = g_node_new(func(node->data, data));
const gchar *ep_;
gint parenthese_cnt = 0;
- g_return_val_if_fail(start != NULL, FALSE);
- g_return_val_if_fail(scanpos != NULL, FALSE);
- g_return_val_if_fail(bp != NULL, FALSE);
- g_return_val_if_fail(ep != NULL, FALSE);
+ cm_return_val_if_fail(start != NULL, FALSE);
+ cm_return_val_if_fail(scanpos != NULL, FALSE);
+ cm_return_val_if_fail(bp != NULL, FALSE);
+ cm_return_val_if_fail(ep != NULL, FALSE);
*bp = scanpos;
* should pass some URI type to this function and decide on that whether
* to perform punctuation stripping */
-#define IS_REAL_PUNCT(ch) (g_ascii_ispunct(ch) && !strchr("/?=-)", ch))
+#define IS_REAL_PUNCT(ch) (g_ascii_ispunct(ch) && !strchr("/?=-_)", ch))
for (; ep_ - 1 > scanpos + 1 &&
IS_REAL_PUNCT(*(ep_ - 1));
"bz", "ca", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl",
"cm", "cn", "co", "cr", "cu", "cv", "cx", "cy", "cz", "de",
"dj", "dk", "dm", "do", "dz", "ec", "ee", "eg", "eh", "er",
- "es", "et", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gd",
+ "es", "et", "eu", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gd",
"ge", "gf", "gg", "gh", "gi", "gl", "gm", "gn", "gp", "gq",
"gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr",
"ht", "hu", "id", "ie", "il", "im", "in", "io", "iq", "ir",
gint n;
GHashTable *htab = g_hash_table_new(g_stricase_hash, g_stricase_equal);
- g_return_val_if_fail(htab, NULL);
+ cm_return_val_if_fail(htab, NULL);
for (n = 0; n < sizeof toplvl_domains / sizeof toplvl_domains[0]; n++)
g_hash_table_insert(htab, (gpointer) toplvl_domains[n], (gpointer) toplvl_domains[n]);
return htab;
gchar closure_stack[128];
gchar *ptr = closure_stack;
- g_return_val_if_fail(start != NULL, FALSE);
- g_return_val_if_fail(scanpos != NULL, FALSE);
- g_return_val_if_fail(bp != NULL, FALSE);
- g_return_val_if_fail(ep != NULL, FALSE);
+ cm_return_val_if_fail(start != NULL, FALSE);
+ cm_return_val_if_fail(scanpos != NULL, FALSE);
+ cm_return_val_if_fail(bp != NULL, FALSE);
+ cm_return_val_if_fail(ep != NULL, FALSE);
if (hdr) {
const gchar *start_quote = NULL;
if (!dom_tab)
dom_tab = create_domain_tab();
- g_return_val_if_fail(dom_tab, FALSE);
+ cm_return_val_if_fail(dom_tab, FALSE);
/* scan start of address */
for (bp_ = scanpos - 1;
if (!result) return FALSE;
- if (*ep_ && *(bp_ - 1) == '"' && *(ep_) == '"'
+ if (*ep_ && bp_ != start && *(bp_ - 1) == '"' && *(ep_) == '"'
&& *(ep_ + 1) == ' ' && *(ep_ + 2) == '<'
&& IS_RFC822_CHAR(*(ep_ + 3))) {
/* this informative part with an @ in it is
POP_STACK();
continue;
}
- if (*bp_ == '\'' || *bp_ == '"') {
+ if (!IN_STACK() && (*bp_ == '\'' || *bp_ == '"')) {
PUSH_STACK(*bp_);
continue;
}
static gchar *mailcap_get_command_in_file(const gchar *path, const gchar *type, const gchar *file_to_open)
{
- FILE *fp = fopen(path, "rb");
+ FILE *fp = g_fopen(path, "rb");
gchar buf[BUFFSIZE];
gchar *result = NULL;
if (!fp)
while (fgets(buf, sizeof (buf), fp) != NULL) {
gchar **parts = g_strsplit(buf, ";", 3);
gchar *trimmed = parts[0];
- while (trimmed[0] == ' ')
+ while (trimmed[0] == ' ' || trimmed[0] == '\t')
trimmed++;
- while (trimmed[strlen(trimmed)-1] == ' ')
+ while (trimmed[strlen(trimmed)-1] == ' ' || trimmed[strlen(trimmed)-1] == '\t')
trimmed[strlen(trimmed)-1] = '\0';
if (!strcmp(trimmed, type)) {
gchar *testcmd = orig_testcmd;
if (strstr(testcmd,";"))
*(strstr(testcmd,";")) = '\0';
- while (testcmd[0] == ' ')
+ while (testcmd[0] == ' ' || testcmd[0] == '\t')
testcmd++;
while (testcmd[strlen(testcmd)-1] == '\n')
testcmd[strlen(testcmd)-1] = '\0';
while (testcmd[strlen(testcmd)-1] == '\r')
testcmd[strlen(testcmd)-1] = '\0';
- while (testcmd[strlen(testcmd)-1] == ' ')
+ while (testcmd[strlen(testcmd)-1] == ' ' || testcmd[strlen(testcmd)-1] == '\t')
testcmd[strlen(testcmd)-1] = '\0';
if (strstr(testcmd, "%s")) {
}
trimmed = parts[1];
- while (trimmed[0] == ' ')
+ while (trimmed[0] == ' ' || trimmed[0] == '\t')
trimmed++;
while (trimmed[strlen(trimmed)-1] == '\n')
trimmed[strlen(trimmed)-1] = '\0';
while (trimmed[strlen(trimmed)-1] == '\r')
trimmed[strlen(trimmed)-1] = '\0';
- while (trimmed[strlen(trimmed)-1] == ' ')
+ while (trimmed[strlen(trimmed)-1] == ' ' || trimmed[strlen(trimmed)-1] == '\t')
trimmed[strlen(trimmed)-1] = '\0';
result = g_strdup(trimmed);
g_strfreev(parts);
gchar *path = NULL, *outpath = NULL;
path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S, ".mailcap", NULL);
outpath = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S, ".mailcap.new", NULL);
- FILE *fp = fopen(path, "rb");
- FILE *outfp = fopen(outpath, "wb");
+ FILE *fp = g_fopen(path, "rb");
+ FILE *outfp = g_fopen(outpath, "wb");
gchar buf[BUFFSIZE];
+ gboolean err = FALSE;
- if (!fp) {
- g_free(path);
- g_free(outpath);
- return;
- }
if (!outfp) {
g_free(path);
g_free(outpath);
fclose(fp);
return;
}
- while (fgets(buf, sizeof (buf), fp) != NULL) {
+ while (fp && fgets(buf, sizeof (buf), fp) != NULL) {
gchar **parts = g_strsplit(buf, ";", 3);
gchar *trimmed = parts[0];
while (trimmed[0] == ' ')
continue;
}
else {
- fputs(buf, outfp);
+ if(fputs(buf, outfp) == EOF) {
+ err = TRUE;
+ break;
+ }
}
g_strfreev(parts);
}
- fprintf(outfp, "%s; %s\n", type, command);
- fclose(fp);
- fclose(outfp);
- g_rename(outpath, path);
+ if (fprintf(outfp, "%s; %s\n", type, command) < 0)
+ err = TRUE;
+
+ if (fp)
+ fclose(fp);
+
+ if (fclose(outfp) == EOF)
+ err = TRUE;
+
+ if (!err)
+ g_rename(outpath, path);
+
+ g_free(path);
+ g_free(outpath);
}
gint copy_dir(const gchar *src, const gchar *dst)
debug_print("copying: %s -> %s\n", old_file, new_file);
if (g_file_test(old_file, G_FILE_TEST_IS_REGULAR)) {
gint r = copy_file(old_file, new_file, TRUE);
- if (r < 0)
+ if (r < 0) {
+ g_dir_close(dir);
+ return r;
+ }
+ }
+#ifndef G_OS_WIN32
+ /* Windows has no symlinks. Or well, Vista seems to
+ have something like this but the semantics might be
+ different. Thus we don't use it under Windows. */
+ else if (g_file_test(old_file, G_FILE_TEST_IS_SYMLINK)) {
+ GError *error;
+ gint r = 0;
+ gchar *target = g_file_read_link(old_file, &error);
+ if (target)
+ r = symlink(target, new_file);
+ g_free(target);
+ if (r < 0) {
+ g_dir_close(dir);
return r;
- } else if (g_file_test(old_file, G_FILE_TEST_IS_DIR)) {
+ }
+ }
+#endif /*G_OS_WIN32*/
+ else if (g_file_test(old_file, G_FILE_TEST_IS_DIR)) {
gint r = copy_dir(old_file, new_file);
- if (r < 0)
+ if (r < 0) {
+ g_dir_close(dir);
return r;
+ }
}
}
+ g_dir_close(dir);
return 0;
}
const gchar *s_daynames[] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
const gchar *s_monthnames[] = {NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL};
+
+gint daynames_len[] = {0,0,0,0,0,0,0};
+gint monthnames_len[] = {0,0,0,0,0,0,
+ 0,0,0,0,0,0};
+gint s_daynames_len[] = {0,0,0,0,0,0,0};
+gint s_monthnames_len[] = {0,0,0,0,0,0,
+ 0,0,0,0,0,0};
const gchar *s_am_up = NULL;
const gchar *s_pm_up = NULL;
const gchar *s_am_low = NULL;
const gchar *s_pm_low = NULL;
+
+gint s_am_up_len = 0;
+gint s_pm_up_len = 0;
+gint s_am_low_len = 0;
+gint s_pm_low_len = 0;
+
const gchar *def_loc_format = NULL;
const gchar *date_loc_format = NULL;
const gchar *time_loc_format = NULL;
static void init_time_names(void)
{
+ int i = 0;
+
daynames[0] = Q_("Complete day name for use by strftime|Sunday");
daynames[1] = Q_("Complete day name for use by strftime|Monday");
daynames[2] = Q_("Complete day name for use by strftime|Tuesday");
daynames[4] = Q_("Complete day name for use by strftime|Thursday");
daynames[5] = Q_("Complete day name for use by strftime|Friday");
daynames[6] = Q_("Complete day name for use by strftime|Saturday");
-
+
monthnames[0] = Q_("Complete month name for use by strftime|January");
monthnames[1] = Q_("Complete month name for use by strftime|February");
monthnames[2] = Q_("Complete month name for use by strftime|March");
s_monthnames[10] = Q_("Abbr. month name for use by strftime|Nov");
s_monthnames[11] = Q_("Abbr. month name for use by strftime|Dec");
+ for (i = 0; i < 7; i++) {
+ daynames_len[i] = strlen(daynames[i]);
+ s_daynames_len[i] = strlen(s_daynames[i]);
+ }
+ for (i = 0; i < 12; i++) {
+ monthnames_len[i] = strlen(monthnames[i]);
+ s_monthnames_len[i] = strlen(s_monthnames[i]);
+ }
+
s_am_up = Q_("For use by strftime (morning)|AM");
s_pm_up = Q_("For use by strftime (afternoon)|PM");
s_am_low = Q_("For use by strftime (morning, lowercase)|am");
s_pm_low = Q_("For use by strftime (afternoon, lowercase)|pm");
+ s_am_up_len = strlen(s_am_up);
+ s_pm_up_len = strlen(s_pm_up);
+ s_am_low_len = strlen(s_am_low);
+ s_pm_low_len = strlen(s_pm_low);
+
def_loc_format = Q_("For use by strftime (default date+time format)|%a %b %e %H:%M:%S %Y");
date_loc_format = Q_("For use by strftime (default date format)|%m/%d/%y");
time_loc_format = Q_("For use by strftime (default time format)|%H:%M:%S");
time_am_pm = Q_("For use by strftime (default 12-hour time format)|%I:%M:%S %p");
time_names_init_done = TRUE;
-#if 0
- {
- struct tm *lt;
- time_t now = time(NULL), next;
- gchar buf_a[1024], buf_b[1024];
-
- printf("test strftime:\n");
- tzset();
- for (next = now; next < now + 86400*365*2; next++) {
- lt = localtime(&now);
- strftime(buf_a, 1024,
- "%a,%A,%b,%B,%c,%C,%d,%D,%e,%F,%G,%g,%h,%H,%I "
- "%j,%k,%l,%m,%M,%n,%p,%P,%r,%R,%s,%S,%t,%T,%u,%U,%V"
- "%w,%W,%x,%X,%y,%Y,%z,%Z,%%,%EY,%OY", lt);
- fast_strftime(buf_b, 1024,
- "%a,%A,%b,%B,%c,%C,%d,%D,%e,%F,%G,%g,%h,%H,%I "
- "%j,%k,%l,%m,%M,%n,%p,%P,%r,%R,%s,%S,%t,%T,%u,%U,%V"
- "%w,%W,%x,%X,%y,%Y,%z,%Z,%%,%EY,%OY", lt);
- if (strcmp(buf_a, buf_b)) {
- printf("diff: \n%s\n%s\n", buf_a, buf_b);
- }
- }
- }
-#endif
}
#define CHECK_SIZE() { \
*curpos = '%';
break;
case 'a':
- len = strlen(s_daynames[lt->tm_wday]); CHECK_SIZE();
+ len = s_daynames_len[lt->tm_wday]; CHECK_SIZE();
strncpy2(curpos, s_daynames[lt->tm_wday], buflen - total_done);
break;
case 'A':
- len = strlen(daynames[lt->tm_wday]); CHECK_SIZE();
+ len = daynames_len[lt->tm_wday]; CHECK_SIZE();
strncpy2(curpos, daynames[lt->tm_wday], buflen - total_done);
break;
case 'b':
case 'h':
- len = strlen(s_monthnames[lt->tm_mon]); CHECK_SIZE();
+ len = s_monthnames_len[lt->tm_mon]; CHECK_SIZE();
strncpy2(curpos, s_monthnames[lt->tm_mon], buflen - total_done);
break;
case 'B':
- len = strlen(monthnames[lt->tm_mon]); CHECK_SIZE();
+ len = monthnames_len[lt->tm_mon]; CHECK_SIZE();
strncpy2(curpos, monthnames[lt->tm_mon], buflen - total_done);
break;
case 'c':
break;
case 'p':
if (lt->tm_hour >= 12) {
- len = strlen(s_pm_up); CHECK_SIZE();
- snprintf(curpos, buflen-total_done, s_pm_up);
+ len = s_pm_up_len; CHECK_SIZE();
+ snprintf(curpos, buflen-total_done, "%s", s_pm_up);
} else {
- len = strlen(s_am_up); CHECK_SIZE();
- snprintf(curpos, buflen-total_done, s_am_up);
+ len = s_am_up_len; CHECK_SIZE();
+ snprintf(curpos, buflen-total_done, "%s", s_am_up);
}
break;
case 'P':
if (lt->tm_hour >= 12) {
- len = strlen(s_pm_low); CHECK_SIZE();
- snprintf(curpos, buflen-total_done, s_pm_low);
+ len = s_pm_low_len; CHECK_SIZE();
+ snprintf(curpos, buflen-total_done, "%s", s_pm_low);
} else {
- len = strlen(s_am_low); CHECK_SIZE();
- snprintf(curpos, buflen-total_done, s_am_low);
+ len = s_am_low_len; CHECK_SIZE();
+ snprintf(curpos, buflen-total_done, "%s", s_am_low);
}
break;
case 'r':
*curpos++ = '0'+(lt->tm_min % 10);
break;
case 's':
- snprintf(subbuf, buflen - total_done, "%ld", mktime(lt));
+ snprintf(subbuf, 64, "%ld", mktime(lt));
len = strlen(subbuf); CHECK_SIZE();
strncpy2(curpos, subbuf, buflen - total_done);
break;
format++;
break;
default:
- g_warning("format error (%c)", *format);
+ if (format && *format)
+ g_warning("format error (%c)", *format);
*curpos = '\0';
return total_done;
}
*curpos++ = '\0';
return total_done;
}
+
+gboolean prefs_common_get_use_shred(void);
+
+
+#ifdef G_OS_WIN32
+#define WEXITSTATUS(x) (x)
+#endif
+
+int claws_unlink(const gchar *filename)
+{
+ struct stat s;
+ static int found_shred = -1;
+ static const gchar *args[4];
+
+ if (filename == NULL)
+ return 0;
+
+ if (prefs_common_get_use_shred()) {
+ if (found_shred == -1) {
+ /* init */
+ args[0] = g_find_program_in_path("shred");
+ debug_print("found shred: %s\n", args[0]);
+ found_shred = (args[0] != NULL) ? 1:0;
+ args[1] = "-f";
+ args[3] = NULL;
+ }
+ if (found_shred == 1) {
+ if (g_stat(filename, &s) == 0 && S_ISREG(s.st_mode)) {
+ if (s.st_nlink == 1) {
+ gint status=0;
+ args[2] = filename;
+ g_spawn_sync(NULL, (gchar **)args, NULL, 0,
+ NULL, NULL, NULL, NULL, &status, NULL);
+ debug_print("%s %s exited with status %d\n",
+ args[0], filename, WEXITSTATUS(status));
+ if (truncate(filename, 0) < 0)
+ g_warning("couln't truncate");
+ }
+ }
+ }
+ }
+ return g_unlink(filename);
+}
projects / claws.git / blobdiff