/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2007 Hiroyuki Yamamoto & The Claws Mail Team
+ * Copyright (C) 1999-2012 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
#ifdef HAVE_CONFIG_H
# include "config.h"
+#include "claws-features.h"
#endif
#include "defs.h"
#include <glib/gi18n.h>
+#ifdef USE_PTHREAD
+#include <pthread.h>
+#endif
+
#include <stdio.h>
#include <string.h>
#include <ctype.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>
-#include <osso-browser-interface.h>
+#ifdef CHINOOK
+# include <tablet-browser-interface.h>
+#else
+# include <osso-browser-interface.h>
+#endif
#endif
#include "utils.h"
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);
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);
}
}
-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;
-}
-
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 < (off_t)1024) {
+ if (size < (goffset)1024) {
g_snprintf(str, sizeof(str), b_format, (gint)size);
return str;
- } else if (size >> 10 < (off_t)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 < (off_t)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;
}
}
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;
goto unlinkout;
}
- if (rename_force(out, file) < 0)
+ if (move_file(out, file, TRUE) < 0)
goto unlinkout;
+ g_free(out);
return 0;
unlinkout:
- g_unlink(out);
+ claws_unlink(out);
freeout:
g_free(out);
return -1;
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;
register gchar *srcp, *destp;
gint in_brace;
- srcp = destp = str;
+ destp = str;
while ((destp = strchr(destp, op))) {
in_brace = 1;
register gchar *srcp, *destp;
gint in_brace;
- srcp = destp = str;
+ destp = str;
while ((srcp = strchr(destp, op))) {
if (destp > str)
gint in_brace;
gboolean in_quote = FALSE;
- srcp = destp = str;
+ destp = str;
while ((srcp = strchr_with_skip_quote(destp, quote_chr, op))) {
if (destp > str)
register gchar *srcp, *destp;
gint in_brace;
- srcp = destp = str;
+ destp = str;
while ((destp = strchr(destp, '"'))) {
if ((srcp = strchr(destp + 1, '"'))) {
}
}
- srcp = destp = str;
+ destp = str;
while ((destp = strchr_with_skip_quote(destp, '"', '('))) {
in_brace = 1;
GList *add_history(GList *list, const gchar *str)
{
GList *old;
+ gchar *oldstr;
- 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) {
- g_free(old->data);
+ oldstr = old->data;
list = g_list_remove(list, old->data);
+ g_free(oldstr);
} else if (g_list_length(list) >= MAX_HISTORY_SIZE) {
GList *last;
last = g_list_last(list);
if (last) {
- g_free(last->data);
+ oldstr = last->data;
list = g_list_remove(list, last->data);
+ g_free(oldstr);
}
}
}
}
-static void subst_chars(gchar *str, gchar *orig, gchar subst)
+void subst_chars(gchar *str, gchar *orig, gchar subst)
{
register gchar *p = str;
int i;
if (quote_chars == NULL)
- return FALSE;
+ return NULL;
for (i = 0; i < strlen(quote_chars); i++) {
tmp_pos = strrchr (str, quote_chars[i]);
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)
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);
}
}
decode_uri_with_plus(decoded_uri, encoded_uri, TRUE);
}
-gint scan_mailto_url(const gchar *mailto, gchar **to, gchar **cc, gchar **bcc,
- gchar **subject, gchar **body, gchar **attach)
+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);
- } else if (attach && !*attach && !g_ascii_strcasecmp(field, "attach")) {
+ *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;
- *attach = g_malloc(strlen(value) + 1);
- decode_uri(*attach, value);
+ gchar *tmp = decode_uri_gdup(value);
for (; forbidden_uris[i]; i++) {
- if (strstr(*attach, forbidden_uris[i])) {
+ if (strstr(tmp, forbidden_uris[i])) {
g_print("Refusing to attach '%s', potential private data leak\n",
- *attach);
- g_free(*attach);
- *attach = NULL;
+ 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;
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
}
#ifdef MAEMO
return template_dir;
}
+#ifdef G_OS_WIN32
+const gchar *get_cert_file(void)
+{
+ 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 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. */
const gchar *get_plugin_dir(void)
{
#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;
gchar buf[BUFFSIZE];
if ((fp = g_fopen(file, "rb")) == NULL) {
- FILE_OP_ERROR(file, "fopen");
+ FILE_OP_ERROR(file, "g_fopen");
return -1;
}
}
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");
}
gchar *prev_dir;
gint file_no;
+ if (first == last) {
+ /* Skip all the dir reading part. */
+ gchar *filename = g_strdup_printf("%s%s%u", dir, G_DIR_SEPARATOR_S, first);
+ if (claws_unlink(filename) < 0) {
+ FILE_OP_ERROR(filename, "unlink");
+ g_free(filename);
+ return -1;
+ }
+ g_free(filename);
+ return 0;
+ }
+
prev_dir = g_get_current_dir();
if (g_chdir(dir) < 0) {
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");
}
}
const gchar *dir_name;
gchar *prev_dir;
gint file_no;
+ GHashTable *file_no_tbl;
+
+ if (numberlist == NULL)
+ return 0;
prev_dir = g_get_current_dir();
return -1;
}
+ file_no_tbl = g_hash_table_new(g_direct_hash, g_direct_equal);
while ((dir_name = g_dir_read_name(dp)) != NULL) {
file_no = to_number(dir_name);
- if (file_no > 0 && (g_slist_find(numberlist, GINT_TO_POINTER(file_no)) == NULL)) {
- 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 (is_dir_exist(dir_name))
+ continue;
+ if (file_no > 0)
+ g_hash_table_insert(file_no_tbl, GINT_TO_POINTER(file_no), GINT_TO_POINTER(1));
+ }
+
+ do {
+ if (g_hash_table_lookup(file_no_tbl, numberlist->data) == NULL) {
+ debug_print("removing unwanted file %d from %s\n",
+ GPOINTER_TO_INT(numberlist->data), dir);
+ if (claws_unlink(dir_name) < 0)
FILE_OP_ERROR(dir_name, "unlink");
}
- }
+ } while ((numberlist = g_slist_next(numberlist)));
g_dir_close(dp);
+ g_hash_table_destroy(file_no_tbl);
if (g_chdir(prev_dir) < 0) {
FILE_OP_ERROR(prev_dir, "chdir");
}
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;
}
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;
}
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;
}
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;
}
gchar *normalize_newlines(const gchar *str)
{
- const gchar *p = str;
+ const gchar *p;
gchar *out, *outp;
out = outp = g_malloc(strlen(str) + 1);
gchar *fname;
gint fd;
FILE *fp;
+#ifndef G_OS_WIN32
gchar buf[2]="\0";
+#endif
tmpdir = get_tmp_dir();
tmplen = strlen(tmpdir);
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) {
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;
}
+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)
{
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) {
{
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 *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);
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",
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;
struct tm buf1, buf2;
-
+#ifdef G_OS_WIN32
+ if (now && *now < 0)
+ return 0;
+#endif
gmt = *gmtime_r(now, &buf1);
lt = localtime_r(now, &buf2);
gint off;
gchar sign = '+';
struct tm buf1, buf2;
-
+#ifdef G_OS_WIN32
+ if (now && *now < 0)
+ return 0;
+#endif
gmt = *gmtime_r(now, &buf1);
lt = localtime_r(now, &buf2);
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;
+ 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;
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;
t = time(NULL);
lt = localtime_r(&t, &buft);
- if (strcmp(buf, "") == 0) {
- addr = g_strconcat("@", get_domain_name(), NULL);
- }
- else {
- addr = g_strconcat("@", buf, NULL);
- }
+ if (user_addr != NULL)
+ addr = g_strdup_printf(".%s", user_addr);
+ else if (strlen(buf) != 0)
+ addr = g_strdup_printf("@%s", buf);
+ else
+ addr = g_strdup_printf("@%s", get_domain_name());
+
+ /* Replace all @ but the last one in addr, with underscores.
+ * RFC 2822 States that msg-id syntax only allows one @.
+ */
+ while (strchr(addr, '@') != NULL && strchr(addr, '@') != strrchr(addr, '@'))
+ *(strchr(addr, '@')) = '_';
g_snprintf(buf, len, "%04d%02d%02d%02d%02d%02d.%08x%s",
lt->tm_year + 1900, lt->tm_mon + 1,
return a quoted string safely usable in argument of a command.
- code is extracted and adapted from etPan! project -- DINH V. Hoà.
+ code is extracted and adapted from etPan! project -- DINH V. Ho�.
*/
gint quote_cmd_argument(gchar * result, guint size,
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));
INT_TO_HEX(hex, ch >> 4);
*out++ = hex;
INT_TO_HEX(hex, ch & 0x0f);
- *out++ = hex;
+ *out = hex;
}
#undef REF_DEBUG
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;
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)
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;
&& fgets(buffer, sizeof (buffer), fp) > 0) {
if (!strncmp(buffer, "From:", strlen("From:")))
score++;
- if (!strncmp(buffer, "To:", strlen("To:")))
+ else if (!strncmp(buffer, "Date:", strlen("Date:")))
+ score++;
+ else if (!strncmp(buffer, "Message-ID:", strlen("Message-ID:")))
score++;
- if (!strncmp(buffer, "Subject:", strlen("Subject:")))
+ else if (!strncmp(buffer, "Subject:", strlen("Subject:")))
score++;
i++;
}
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");
*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++ = *format++;
}
}
- *curpos++ = '\0';
+ *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);
+}
+
+GMutex *cm_mutex_new(void) {
+#if GLIB_CHECK_VERSION(2,32,0)
+ GMutex *m = g_new0(GMutex, 1);
+ g_mutex_init(m);
+ return m;
+#else
+ return g_mutex_new();
+#endif
+}
+
+void cm_mutex_free(GMutex *mutex) {
+#if GLIB_CHECK_VERSION(2,32,0)
+ g_mutex_clear(mutex);
+ g_free(mutex);
+#else
+ g_mutex_free(mutex);
+#endif
+}
projects / claws.git / blobdiff