54f06ca1a30b7a41f6be6e11586f76944de174f1
[claws.git] / src / common / utils.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2006 Hiroyuki Yamamoto & The Claws Mail Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include "defs.h"
25
26 #include <glib.h>
27
28 #include <glib/gi18n.h>
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <errno.h>
34
35 #if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
36 #  include <wchar.h>
37 #  include <wctype.h>
38 #endif
39 #include <stdlib.h>
40 #include <sys/stat.h>
41 #include <unistd.h>
42 #include <stdarg.h>
43 #include <sys/types.h>
44 #if HAVE_SYS_WAIT_H
45 #  include <sys/wait.h>
46 #endif
47 #include <dirent.h>
48 #include <time.h>
49 #include <regex.h>
50
51 #ifdef G_OS_UNIX
52 #include <sys/utsname.h>
53 #endif
54
55 #ifdef G_OS_WIN32
56 #  include <direct.h>
57 #  include <io.h>
58 #  include <fcntl.h>
59 #endif
60
61 #include "utils.h"
62 #include "socket.h"
63 #include "../codeconv.h"
64
65 #define BUFFSIZE        8192
66
67 static gboolean debug_mode = FALSE;
68 #ifdef G_OS_WIN32
69 static GSList *tempfiles=NULL;
70 #endif
71
72
73 #if !GLIB_CHECK_VERSION(2, 7, 0) && !defined(G_OS_UNIX)
74 gint g_chdir(const gchar *path)
75 {
76 #ifdef G_OS_WIN32
77         if (G_WIN32_HAVE_WIDECHAR_API()) {
78                 wchar_t *wpath;
79                 gint retval;
80                 gint save_errno;
81
82                 wpath = g_utf8_to_utf16(path, -1, NULL, NULL, NULL);
83                 if (wpath == NULL) {
84                         errno = EINVAL;
85                         return -1;
86                 }
87
88                 retval = _wchdir(wpath);
89                 save_errno = errno;
90
91                 g_free(wpath);
92
93                 errno = save_errno;
94                 return retval;
95         } else {
96                 gchar *cp_path;
97                 gint retval;
98                 gint save_errno;
99
100                 cp_path = g_locale_from_utf8(path, -1, NULL, NULL, NULL);
101                 if (cp_path == NULL) {
102                         errno = EINVAL;
103                         return -1;
104                 }
105
106                 retval = chdir(cp_path);
107                 save_errno = errno;
108
109                 g_free(cp_path);
110
111                 errno = save_errno;
112                 return retval;
113         }
114 #else
115         return chdir(path);
116 #endif
117 }
118
119 gint g_chmod(const gchar *path, gint mode)
120 {
121 #ifdef G_OS_WIN32
122         if (G_WIN32_HAVE_WIDECHAR_API()) {
123                 wchar_t *wpath;
124                 gint retval;
125                 gint save_errno;
126
127                 wpath = g_utf8_to_utf16(path, -1, NULL, NULL, NULL);
128                 if (wpath == NULL) {
129                         errno = EINVAL;
130                         return -1;
131                 }
132
133                 retval = _wchmod(wpath, mode);
134                 save_errno = errno;
135
136                 g_free(wpath);
137
138                 errno = save_errno;
139                 return retval;
140         } else {
141                 gchar *cp_path;
142                 gint retval;
143                 gint save_errno;
144
145                 cp_path = g_locale_from_utf8(path, -1, NULL, NULL, NULL);
146                 if (cp_path == NULL) {
147                         errno = EINVAL;
148                         return -1;
149                 }
150
151                 retval = chmod(cp_path, mode);
152                 save_errno = errno;
153
154                 g_free(cp_path);
155
156                 errno = save_errno;
157                 return retval;
158         }
159 #else
160         return chmod(path, mode);
161 #endif
162 }
163 #endif /* GLIB_CHECK_VERSION && G_OS_UNIX */
164
165
166 #ifdef G_OS_WIN32
167 gint mkstemp_name(const gchar *template, gchar **name_used)
168 {
169         static gulong count=0; /* W32-_mktemp only supports up to 27
170                                   tempfiles... */
171         int tmpfd;
172
173         *name_used = g_strdup_printf("%s.%ld",_mktemp(template),count++);
174         tmpfd = open (*name_used, (O_CREAT | O_RDWR | O_BINARY),
175                                     (S_IRUSR | S_IWUSR));
176
177         tempfiles=g_slist_append(tempfiles, g_strdup(*name_used));
178         if (tmpfd<0) {
179                 perror(g_strdup_printf("cant create %s",*name_used));
180                 return -1;
181         }
182         else
183                 return tmpfd;
184 }
185 #endif /* G_OS_WIN32 */
186
187 #ifdef G_OS_WIN32
188 gint mkstemp(const gchar *template)
189 {
190         gchar *dummyname;
191         gint res = mkstemp_name(template, &dummyname);
192         g_free(dummyname);
193         return res;
194 }
195 #endif /* G_OS_WIN32 */
196
197 void list_free_strings(GList *list)
198 {
199         list = g_list_first(list);
200
201         while (list != NULL) {
202                 g_free(list->data);
203                 list = list->next;
204         }
205 }
206
207 void slist_free_strings(GSList *list)
208 {
209         while (list != NULL) {
210                 g_free(list->data);
211                 list = list->next;
212         }
213 }
214
215 GSList *slist_concat_unique (GSList *first, GSList *second)
216 {
217         GSList *tmp, *ret;
218         if (first == NULL) {
219                 if (second == NULL)
220                         return NULL;
221                 else
222                         return second;
223         } else if (second == NULL)
224                 return first;
225         ret = first;
226         for (tmp = second; tmp != NULL; tmp = g_slist_next(tmp)) {
227                 if (g_slist_find(ret, tmp->data) == NULL)
228                         ret = g_slist_prepend(ret, tmp->data);
229         }
230         return ret;
231 }
232
233 static void hash_free_strings_func(gpointer key, gpointer value, gpointer data)
234 {
235         g_free(key);
236 }
237
238 void hash_free_strings(GHashTable *table)
239 {
240         g_hash_table_foreach(table, hash_free_strings_func, NULL);
241 }
242
243 static void hash_free_value_mem_func(gpointer key, gpointer value,
244                                      gpointer data)
245 {
246         g_free(value);
247 }
248
249 void hash_free_value_mem(GHashTable *table)
250 {
251         g_hash_table_foreach(table, hash_free_value_mem_func, NULL);
252 }
253
254 gint str_case_equal(gconstpointer v, gconstpointer v2)
255 {
256         return g_ascii_strcasecmp((const gchar *)v, (const gchar *)v2) == 0;
257 }
258
259 guint str_case_hash(gconstpointer key)
260 {
261         const gchar *p = key;
262         guint h = *p;
263
264         if (h) {
265                 h = g_ascii_tolower(h);
266                 for (p += 1; *p != '\0'; p++)
267                         h = (h << 5) - h + g_ascii_tolower(*p);
268         }
269
270         return h;
271 }
272
273 void ptr_array_free_strings(GPtrArray *array)
274 {
275         gint i;
276         gchar *str;
277
278         g_return_if_fail(array != NULL);
279
280         for (i = 0; i < array->len; i++) {
281                 str = g_ptr_array_index(array, i);
282                 g_free(str);
283         }
284 }
285
286 gboolean str_find(const gchar *haystack, const gchar *needle)
287 {
288         return strstr(haystack, needle) != NULL ? TRUE : FALSE;
289 }
290
291 gboolean str_case_find(const gchar *haystack, const gchar *needle)
292 {
293         return strcasestr(haystack, needle) != NULL ? TRUE : FALSE;
294 }
295
296 gboolean str_find_equal(const gchar *haystack, const gchar *needle)
297 {
298         return strcmp(haystack, needle) == 0;
299 }
300
301 gboolean str_case_find_equal(const gchar *haystack, const gchar *needle)
302 {
303         return g_ascii_strcasecmp(haystack, needle) == 0;
304 }
305
306 gint to_number(const gchar *nstr)
307 {
308         register const gchar *p;
309
310         if (*nstr == '\0') return -1;
311
312         for (p = nstr; *p != '\0'; p++)
313                 if (!g_ascii_isdigit(*p)) return -1;
314
315         return atoi(nstr);
316 }
317
318 /* convert integer into string,
319    nstr must be not lower than 11 characters length */
320 gchar *itos_buf(gchar *nstr, gint n)
321 {
322         g_snprintf(nstr, 11, "%d", n);
323         return nstr;
324 }
325
326 /* convert integer into string */
327 gchar *itos(gint n)
328 {
329         static gchar nstr[11];
330
331         return itos_buf(nstr, n);
332 }
333
334 #define divide(num,divisor,i,d)         \
335 {                                       \
336         i = num >> divisor;             \
337         d = num & ((1<<divisor)-1);     \
338         d = (d*100) >> divisor;         \
339 }
340
341 gchar *to_human_readable(off_t size)
342 {
343         static gchar str[14];
344         static gchar *b_format = NULL, *kb_format = NULL, 
345                      *mb_format = NULL, *gb_format = NULL;
346         register int t = 0, r = 0;
347         if (b_format == NULL) {
348                 b_format  = _("%dB");
349                 kb_format = _("%d.%02dKB");
350                 mb_format = _("%d.%02dMB");
351                 gb_format = _("%.2fGB");
352         }
353         
354         if (size < (off_t)1024) {
355                 g_snprintf(str, sizeof(str), b_format, (gint)size);
356                 return str;
357         } else if (size >> 10 < (off_t)1024) {
358                 divide(size, 10, t, r);
359                 g_snprintf(str, sizeof(str), kb_format, t, r);
360                 return str;
361         } else if (size >> 20 < (off_t)1024) {
362                 divide(size, 20, t, r);
363                 g_snprintf(str, sizeof(str), mb_format, t, r);
364                 return str;
365         } else {
366                 g_snprintf(str, sizeof(str), gb_format, (gfloat)size / (1 << 30));
367                 return str;
368         }
369 }
370
371 /* strcmp with NULL-checking */
372 gint strcmp2(const gchar *s1, const gchar *s2)
373 {
374         if (s1 == NULL || s2 == NULL)
375                 return -1;
376         else
377                 return strcmp(s1, s2);
378 }
379 /* strstr with NULL-checking */
380 gchar *strstr2(const gchar *s1, const gchar *s2)
381 {
382         if (s1 == NULL || s2 == NULL)
383                 return NULL;
384         else
385                 return strstr(s1, s2);
386 }
387 /* compare paths */
388 gint path_cmp(const gchar *s1, const gchar *s2)
389 {
390         gint len1, len2;
391         int rc;
392 #ifdef G_OS_WIN32
393         gchar *s1buf, *s2buf;
394 #endif
395
396         if (s1 == NULL || s2 == NULL) return -1;
397         if (*s1 == '\0' || *s2 == '\0') return -1;
398
399 #ifdef G_OS_WIN32
400         s1buf = g_strdup (s1);
401         s2buf = g_strdup (s2);
402         subst_char (s1buf, '/', G_DIR_SEPARATOR);
403         subst_char (s2buf, '/', G_DIR_SEPARATOR);
404         s1 = s1buf;
405         s2 = s2buf;
406 #endif /* !G_OS_WIN32 */
407
408         len1 = strlen(s1);
409         len2 = strlen(s2);
410
411         if (s1[len1 - 1] == G_DIR_SEPARATOR) len1--;
412         if (s2[len2 - 1] == G_DIR_SEPARATOR) len2--;
413
414         rc = strncmp(s1, s2, MAX(len1, len2));
415 #ifdef G_OS_WIN32
416         g_free (s1buf);
417         g_free (s2buf);
418 #endif /* !G_OS_WIN32 */
419         return rc;
420 }
421
422 /* remove trailing return code */
423 gchar *strretchomp(gchar *str)
424 {
425         register gchar *s;
426
427         if (!*str) return str;
428
429         for (s = str + strlen(str) - 1;
430              s >= str && (*s == '\n' || *s == '\r');
431              s--)
432                 *s = '\0';
433
434         return str;
435 }
436
437 /* remove trailing character */
438 gchar *strtailchomp(gchar *str, gchar tail_char)
439 {
440         register gchar *s;
441
442         if (!*str) return str;
443         if (tail_char == '\0') return str;
444
445         for (s = str + strlen(str) - 1; s >= str && *s == tail_char; s--)
446                 *s = '\0';
447
448         return str;
449 }
450
451 /* remove CR (carriage return) */
452 gchar *strcrchomp(gchar *str)
453 {
454         register gchar *s;
455
456         if (!*str) return str;
457
458         s = str + strlen(str) - 1;
459         if (*s == '\n' && s > str && *(s - 1) == '\r') {
460                 *(s - 1) = '\n';
461                 *s = '\0';
462         }
463
464         return str;
465 }
466
467 void file_strip_crs(const gchar *file)
468 {
469         FILE *fp = NULL, *outfp = NULL;
470         gchar buf[4096];
471         gchar *out = get_tmp_file();
472         if (file == NULL)
473                 goto freeout;
474
475         fp = fopen(file, "rb");
476         if (!fp)
477                 goto freeout;
478
479         outfp = fopen(out, "wb");
480         if (!outfp) {
481                 fclose(fp);
482                 goto freeout;
483         }
484
485         while (fgets(buf, sizeof (buf), fp) != NULL) {
486                 strcrchomp(buf);
487                 fputs(buf, outfp);
488         }
489
490         fclose(fp);
491         fclose(outfp);
492         rename_force(out, file);
493 freeout:
494         g_free(out);
495 }
496
497 /* Similar to `strstr' but this function ignores the case of both strings.  */
498 gchar *strcasestr(const gchar *haystack, const gchar *needle)
499 {
500         register size_t haystack_len, needle_len;
501
502         haystack_len = strlen(haystack);
503         needle_len   = strlen(needle);
504
505         if (haystack_len < needle_len || needle_len == 0)
506                 return NULL;
507
508         while (haystack_len >= needle_len) {
509                 if (!g_ascii_strncasecmp(haystack, needle, needle_len))
510                         return (gchar *)haystack;
511                 else {
512                         haystack++;
513                         haystack_len--;
514                 }
515         }
516
517         return NULL;
518 }
519
520 gpointer my_memmem(gconstpointer haystack, size_t haystacklen,
521                    gconstpointer needle, size_t needlelen)
522 {
523         const gchar *haystack_ = (const gchar *)haystack;
524         const gchar *needle_ = (const gchar *)needle;
525         const gchar *haystack_cur = (const gchar *)haystack;
526
527         if (needlelen == 1)
528                 return memchr(haystack_, *needle_, haystacklen);
529
530         while ((haystack_cur = memchr(haystack_cur, *needle_, haystacklen))
531                != NULL) {
532                 if (haystacklen - (haystack_cur - haystack_) < needlelen)
533                         break;
534                 if (memcmp(haystack_cur + 1, needle_ + 1, needlelen - 1) == 0)
535                         return (gpointer)haystack_cur;
536                 else
537                         haystack_cur++;
538         }
539
540         return NULL;
541 }
542
543 /* Copy no more than N characters of SRC to DEST, with NULL terminating.  */
544 gchar *strncpy2(gchar *dest, const gchar *src, size_t n)
545 {
546         register const gchar *s = src;
547         register gchar *d = dest;
548
549         while (--n && *s)
550                 *d++ = *s++;
551         *d = '\0';
552
553         return dest;
554 }
555
556
557 /* Examine if next block is non-ASCII string */
558 gboolean is_next_nonascii(const gchar *s)
559 {
560         const gchar *p;
561
562         /* skip head space */
563         for (p = s; *p != '\0' && g_ascii_isspace(*p); p++)
564                 ;
565         for (; *p != '\0' && !g_ascii_isspace(*p); p++) {
566                 if (*(guchar *)p > 127 || *(guchar *)p < 32)
567                         return TRUE;
568         }
569
570         return FALSE;
571 }
572
573 gint get_next_word_len(const gchar *s)
574 {
575         gint len = 0;
576
577         for (; *s != '\0' && !g_ascii_isspace(*s); s++, len++)
578                 ;
579
580         return len;
581 }
582
583 /* compare subjects */
584 gint subject_compare(const gchar *s1, const gchar *s2)
585 {
586         gchar *str1, *str2;
587
588         if (!s1 || !s2) return -1;
589         if (!*s1 || !*s2) return -1;
590
591         Xstrdup_a(str1, s1, return -1);
592         Xstrdup_a(str2, s2, return -1);
593
594         trim_subject_for_compare(str1);
595         trim_subject_for_compare(str2);
596
597         if (!*str1 || !*str2) return -1;
598
599         return strcmp(str1, str2);
600 }
601
602 gint subject_compare_for_sort(const gchar *s1, const gchar *s2)
603 {
604         gchar *str1, *str2;
605
606         if (!s1 || !s2) return -1;
607
608         Xstrdup_a(str1, s1, return -1);
609         Xstrdup_a(str2, s2, return -1);
610
611         trim_subject_for_sort(str1);
612         trim_subject_for_sort(str2);
613
614         return g_utf8_collate(str1, str2);
615 }
616
617 void trim_subject_for_compare(gchar *str)
618 {
619         gchar *srcp;
620
621         eliminate_parenthesis(str, '[', ']');
622         eliminate_parenthesis(str, '(', ')');
623         g_strstrip(str);
624
625         srcp = str + subject_get_prefix_length(str);
626         if (srcp != str)
627                 memmove(str, srcp, strlen(srcp) + 1);
628 }
629
630 void trim_subject_for_sort(gchar *str)
631 {
632         gchar *srcp;
633
634         g_strstrip(str);
635
636         srcp = str + subject_get_prefix_length(str);
637         if (srcp != str)
638                 memmove(str, srcp, strlen(srcp) + 1);
639 }
640
641 void trim_subject(gchar *str)
642 {
643         register gchar *srcp;
644         gchar op, cl;
645         gint in_brace;
646
647         g_strstrip(str);
648
649         srcp = str + subject_get_prefix_length(str);
650
651         if (*srcp == '[') {
652                 op = '[';
653                 cl = ']';
654         } else if (*srcp == '(') {
655                 op = '(';
656                 cl = ')';
657         } else
658                 op = 0;
659
660         if (op) {
661                 ++srcp;
662                 in_brace = 1;
663                 while (*srcp) {
664                         if (*srcp == op)
665                                 in_brace++;
666                         else if (*srcp == cl)
667                                 in_brace--;
668                         srcp++;
669                         if (in_brace == 0)
670                                 break;
671                 }
672         }
673         while (g_ascii_isspace(*srcp)) srcp++;
674         memmove(str, srcp, strlen(srcp) + 1);
675 }
676
677 void eliminate_parenthesis(gchar *str, gchar op, gchar cl)
678 {
679         register gchar *srcp, *destp;
680         gint in_brace;
681
682         srcp = destp = str;
683
684         while ((destp = strchr(destp, op))) {
685                 in_brace = 1;
686                 srcp = destp + 1;
687                 while (*srcp) {
688                         if (*srcp == op)
689                                 in_brace++;
690                         else if (*srcp == cl)
691                                 in_brace--;
692                         srcp++;
693                         if (in_brace == 0)
694                                 break;
695                 }
696                 while (g_ascii_isspace(*srcp)) srcp++;
697                 memmove(destp, srcp, strlen(srcp) + 1);
698         }
699 }
700
701 void extract_parenthesis(gchar *str, gchar op, gchar cl)
702 {
703         register gchar *srcp, *destp;
704         gint in_brace;
705
706         srcp = destp = str;
707
708         while ((srcp = strchr(destp, op))) {
709                 if (destp > str)
710                         *destp++ = ' ';
711                 memmove(destp, srcp + 1, strlen(srcp));
712                 in_brace = 1;
713                 while(*destp) {
714                         if (*destp == op)
715                                 in_brace++;
716                         else if (*destp == cl)
717                                 in_brace--;
718
719                         if (in_brace == 0)
720                                 break;
721
722                         destp++;
723                 }
724         }
725         *destp = '\0';
726 }
727
728 void extract_parenthesis_with_skip_quote(gchar *str, gchar quote_chr,
729                                          gchar op, gchar cl)
730 {
731         register gchar *srcp, *destp;
732         gint in_brace;
733         gboolean in_quote = FALSE;
734
735         srcp = destp = str;
736
737         while ((srcp = strchr_with_skip_quote(destp, quote_chr, op))) {
738                 if (destp > str)
739                         *destp++ = ' ';
740                 memmove(destp, srcp + 1, strlen(srcp));
741                 in_brace = 1;
742                 while(*destp) {
743                         if (*destp == op && !in_quote)
744                                 in_brace++;
745                         else if (*destp == cl && !in_quote)
746                                 in_brace--;
747                         else if (*destp == quote_chr)
748                                 in_quote ^= TRUE;
749
750                         if (in_brace == 0)
751                                 break;
752
753                         destp++;
754                 }
755         }
756         *destp = '\0';
757 }
758
759 void eliminate_quote(gchar *str, gchar quote_chr)
760 {
761         register gchar *srcp, *destp;
762
763         srcp = destp = str;
764
765         while ((destp = strchr(destp, quote_chr))) {
766                 if ((srcp = strchr(destp + 1, quote_chr))) {
767                         srcp++;
768                         while (g_ascii_isspace(*srcp)) srcp++;
769                         memmove(destp, srcp, strlen(srcp) + 1);
770                 } else {
771                         *destp = '\0';
772                         break;
773                 }
774         }
775 }
776
777 void extract_quote(gchar *str, gchar quote_chr)
778 {
779         register gchar *p;
780
781         if ((str = strchr(str, quote_chr))) {
782                 p = str;
783                 while ((p = strchr(p + 1, quote_chr)) && (p[-1] == '\\')) {
784                         memmove(p - 1, p, strlen(p) + 1);
785                         p--;
786                 }
787                 if(p) {
788                         *p = '\0';
789                         memmove(str, str + 1, p - str);
790                 }
791         }
792 }
793
794 void eliminate_address_comment(gchar *str)
795 {
796         register gchar *srcp, *destp;
797         gint in_brace;
798
799         srcp = destp = str;
800
801         while ((destp = strchr(destp, '"'))) {
802                 if ((srcp = strchr(destp + 1, '"'))) {
803                         srcp++;
804                         if (*srcp == '@') {
805                                 destp = srcp + 1;
806                         } else {
807                                 while (g_ascii_isspace(*srcp)) srcp++;
808                                 memmove(destp, srcp, strlen(srcp) + 1);
809                         }
810                 } else {
811                         *destp = '\0';
812                         break;
813                 }
814         }
815
816         srcp = destp = str;
817
818         while ((destp = strchr_with_skip_quote(destp, '"', '('))) {
819                 in_brace = 1;
820                 srcp = destp + 1;
821                 while (*srcp) {
822                         if (*srcp == '(')
823                                 in_brace++;
824                         else if (*srcp == ')')
825                                 in_brace--;
826                         srcp++;
827                         if (in_brace == 0)
828                                 break;
829                 }
830                 while (g_ascii_isspace(*srcp)) srcp++;
831                 memmove(destp, srcp, strlen(srcp) + 1);
832         }
833 }
834
835 gchar *strchr_with_skip_quote(const gchar *str, gint quote_chr, gint c)
836 {
837         gboolean in_quote = FALSE;
838
839         while (*str) {
840                 if (*str == c && !in_quote)
841                         return (gchar *)str;
842                 if (*str == quote_chr)
843                         in_quote ^= TRUE;
844                 str++;
845         }
846
847         return NULL;
848 }
849
850 gchar *strrchr_with_skip_quote(const gchar *str, gint quote_chr, gint c)
851 {
852         gboolean in_quote = FALSE;
853         const gchar *p;
854
855         p = str + strlen(str) - 1;
856         while (p >= str) {
857                 if (*p == c && !in_quote)
858                         return (gchar *)p;
859                 if (*p == quote_chr)
860                         in_quote ^= TRUE;
861                 p--;
862         }
863
864         return NULL;
865 }
866
867 void extract_address(gchar *str)
868 {
869         eliminate_address_comment(str);
870         if (strchr_with_skip_quote(str, '"', '<'))
871                 extract_parenthesis_with_skip_quote(str, '"', '<', '>');
872         g_strstrip(str);
873 }
874
875 void extract_list_id_str(gchar *str)
876 {
877         if (strchr_with_skip_quote(str, '"', '<'))
878                 extract_parenthesis_with_skip_quote(str, '"', '<', '>');
879         g_strstrip(str);
880 }
881
882 static GSList *address_list_append_real(GSList *addr_list, const gchar *str, gboolean removecomments)
883 {
884         gchar *work;
885         gchar *workp;
886
887         if (!str) return addr_list;
888
889         Xstrdup_a(work, str, return addr_list);
890
891         if (removecomments)
892                 eliminate_address_comment(work);
893         workp = work;
894
895         while (workp && *workp) {
896                 gchar *p, *next;
897
898                 if ((p = strchr_with_skip_quote(workp, '"', ','))) {
899                         *p = '\0';
900                         next = p + 1;
901                 } else
902                         next = NULL;
903
904                 if (removecomments && strchr_with_skip_quote(workp, '"', '<'))
905                         extract_parenthesis_with_skip_quote
906                                 (workp, '"', '<', '>');
907
908                 g_strstrip(workp);
909                 if (*workp)
910                         addr_list = g_slist_append(addr_list, g_strdup(workp));
911
912                 workp = next;
913         }
914
915         return addr_list;
916 }
917
918 GSList *address_list_append(GSList *addr_list, const gchar *str)
919 {
920         return address_list_append_real(addr_list, str, TRUE);
921 }
922
923 GSList *address_list_append_with_comments(GSList *addr_list, const gchar *str)
924 {
925         return address_list_append_real(addr_list, str, FALSE);
926 }
927
928 GSList *references_list_prepend(GSList *msgid_list, const gchar *str)
929 {
930         const gchar *strp;
931
932         if (!str) return msgid_list;
933         strp = str;
934
935         while (strp && *strp) {
936                 const gchar *start, *end;
937                 gchar *msgid;
938
939                 if ((start = strchr(strp, '<')) != NULL) {
940                         end = strchr(start + 1, '>');
941                         if (!end) break;
942                 } else
943                         break;
944
945                 msgid = g_strndup(start + 1, end - start - 1);
946                 g_strstrip(msgid);
947                 if (*msgid)
948                         msgid_list = g_slist_prepend(msgid_list, msgid);
949                 else
950                         g_free(msgid);
951
952                 strp = end + 1;
953         }
954
955         return msgid_list;
956 }
957
958 GSList *references_list_append(GSList *msgid_list, const gchar *str)
959 {
960         GSList *list;
961
962         list = references_list_prepend(NULL, str);
963         list = g_slist_reverse(list);
964         msgid_list = g_slist_concat(msgid_list, list);
965
966         return msgid_list;
967 }
968
969 GSList *newsgroup_list_append(GSList *group_list, const gchar *str)
970 {
971         gchar *work;
972         gchar *workp;
973
974         if (!str) return group_list;
975
976         Xstrdup_a(work, str, return group_list);
977
978         workp = work;
979
980         while (workp && *workp) {
981                 gchar *p, *next;
982
983                 if ((p = strchr_with_skip_quote(workp, '"', ','))) {
984                         *p = '\0';
985                         next = p + 1;
986                 } else
987                         next = NULL;
988
989                 g_strstrip(workp);
990                 if (*workp)
991                         group_list = g_slist_append(group_list,
992                                                     g_strdup(workp));
993
994                 workp = next;
995         }
996
997         return group_list;
998 }
999
1000 GList *add_history(GList *list, const gchar *str)
1001 {
1002         GList *old;
1003
1004         g_return_val_if_fail(str != NULL, list);
1005
1006         old = g_list_find_custom(list, (gpointer)str, (GCompareFunc)strcmp2);
1007         if (old) {
1008                 g_free(old->data);
1009                 list = g_list_remove(list, old->data);
1010         } else if (g_list_length(list) >= MAX_HISTORY_SIZE) {
1011                 GList *last;
1012
1013                 last = g_list_last(list);
1014                 if (last) {
1015                         g_free(last->data);
1016                         list = g_list_remove(list, last->data);
1017                 }
1018         }
1019
1020         list = g_list_prepend(list, g_strdup(str));
1021
1022         return list;
1023 }
1024
1025 void remove_return(gchar *str)
1026 {
1027         register gchar *p = str;
1028
1029         while (*p) {
1030                 if (*p == '\n' || *p == '\r')
1031                         memmove(p, p + 1, strlen(p));
1032                 else
1033                         p++;
1034         }
1035 }
1036
1037 void remove_space(gchar *str)
1038 {
1039         register gchar *p = str;
1040         register gint spc;
1041
1042         while (*p) {
1043                 spc = 0;
1044                 while (g_ascii_isspace(*(p + spc)))
1045                         spc++;
1046                 if (spc)
1047                         memmove(p, p + spc, strlen(p + spc) + 1);
1048                 else
1049                         p++;
1050         }
1051 }
1052
1053 void unfold_line(gchar *str)
1054 {
1055         register gchar *p = str;
1056         register gint spc;
1057
1058         while (*p) {
1059                 if (*p == '\n' || *p == '\r') {
1060                         *p++ = ' ';
1061                         spc = 0;
1062                         while (g_ascii_isspace(*(p + spc)))
1063                                 spc++;
1064                         if (spc)
1065                                 memmove(p, p + spc, strlen(p + spc) + 1);
1066                 } else
1067                         p++;
1068         }
1069 }
1070
1071 void subst_char(gchar *str, gchar orig, gchar subst)
1072 {
1073         register gchar *p = str;
1074
1075         while (*p) {
1076                 if (*p == orig)
1077                         *p = subst;
1078                 p++;
1079         }
1080 }
1081
1082 void subst_chars(gchar *str, gchar *orig, gchar subst)
1083 {
1084         register gchar *p = str;
1085
1086         while (*p) {
1087                 if (strchr(orig, *p) != NULL)
1088                         *p = subst;
1089                 p++;
1090         }
1091 }
1092
1093 void subst_for_filename(gchar *str)
1094 {
1095         if (!str)
1096                 return;
1097 #ifdef G_OS_WIN32
1098         subst_chars(str, "\t\r\n\\/*:", '_');
1099 #else
1100         subst_chars(str, "\t\r\n\\/*", '_');
1101 #endif
1102 }
1103
1104 void subst_for_shellsafe_filename(gchar *str)
1105 {
1106         if (!str)
1107                 return;
1108         subst_for_filename(str);
1109         subst_chars(str, " \"'|&;()<>'!{}[]",'_');
1110 }
1111
1112 gboolean is_header_line(const gchar *str)
1113 {
1114         if (str[0] == ':') return FALSE;
1115
1116         while (*str != '\0' && *str != ' ') {
1117                 if (*str == ':')
1118                         return TRUE;
1119                 str++;
1120         }
1121
1122         return FALSE;
1123 }
1124
1125 gboolean is_ascii_str(const gchar *str)
1126 {
1127         const guchar *p = (const guchar *)str;
1128
1129         while (*p != '\0') {
1130                 if (*p != '\t' && *p != ' ' &&
1131                     *p != '\r' && *p != '\n' &&
1132                     (*p < 32 || *p >= 127))
1133                         return FALSE;
1134                 p++;
1135         }
1136
1137         return TRUE;
1138 }
1139
1140 gint get_quote_level(const gchar *str, const gchar *quote_chars)
1141 {
1142         const gchar *first_pos;
1143         const gchar *last_pos;
1144         const gchar *p = str;
1145         gint quote_level = -1;
1146
1147         /* speed up line processing by only searching to the last '>' */
1148         if ((first_pos = line_has_quote_char(str, quote_chars)) != NULL) {
1149                 /* skip a line if it contains a '<' before the initial '>' */
1150                 if (memchr(str, '<', first_pos - str) != NULL)
1151                         return -1;
1152                 last_pos = line_has_quote_char_last(first_pos, quote_chars);
1153         } else
1154                 return -1;
1155
1156         while (p <= last_pos) {
1157                 while (p < last_pos) {
1158                         if (g_ascii_isspace(*p))
1159                                 p++;
1160                         else
1161                                 break;
1162                 }
1163
1164                 if (strchr(quote_chars, *p))
1165                         quote_level++;
1166                 else if (*p != '-' && !g_ascii_isspace(*p) && p <= last_pos) {
1167                         /* any characters are allowed except '-' and space */
1168                         while (*p != '-'
1169                                && !strchr(quote_chars, *p)
1170                                && !g_ascii_isspace(*p)
1171                                && p < last_pos)
1172                                 p++;
1173                         if (strchr(quote_chars, *p))
1174                                 quote_level++;
1175                         else
1176                                 break;
1177                 }
1178
1179                 p++;
1180         }
1181
1182         return quote_level;
1183 }
1184
1185 gint check_line_length(const gchar *str, gint max_chars, gint *line)
1186 {
1187         const gchar *p = str, *q;
1188         gint cur_line = 0, len;
1189
1190         while ((q = strchr(p, '\n')) != NULL) {
1191                 len = q - p + 1;
1192                 if (len > max_chars) {
1193                         if (line)
1194                                 *line = cur_line;
1195                         return -1;
1196                 }
1197                 p = q + 1;
1198                 ++cur_line;
1199         }
1200
1201         len = strlen(p);
1202         if (len > max_chars) {
1203                 if (line)
1204                         *line = cur_line;
1205                 return -1;
1206         }
1207
1208         return 0;
1209 }
1210
1211 const gchar * line_has_quote_char(const gchar * str, const gchar *quote_chars)
1212 {
1213         gchar * position = NULL;
1214         gchar * tmp_pos = NULL;
1215         int i;
1216
1217         if (quote_chars == NULL)
1218                 return FALSE;
1219
1220         for (i = 0; i < strlen(quote_chars); i++) {
1221                 tmp_pos = strchr (str,  quote_chars[i]);
1222                 if(position == NULL
1223                    || (tmp_pos != NULL && position >= tmp_pos) )
1224                         position = tmp_pos;
1225         }
1226         return position;
1227 }
1228
1229 const gchar * line_has_quote_char_last(const gchar * str, const gchar *quote_chars)
1230 {
1231         gchar * position = NULL;
1232         gchar * tmp_pos = NULL;
1233         int i;
1234
1235         if (quote_chars == NULL)
1236                 return FALSE;
1237
1238         for (i = 0; i < strlen(quote_chars); i++) {
1239                 tmp_pos = strrchr (str, quote_chars[i]);
1240                 if(position == NULL
1241                    || (tmp_pos != NULL && position <= tmp_pos) )
1242                         position = tmp_pos;
1243         }
1244         return position;
1245 }
1246
1247 gchar *strstr_with_skip_quote(const gchar *haystack, const gchar *needle)
1248 {
1249         register guint haystack_len, needle_len;
1250         gboolean in_squote = FALSE, in_dquote = FALSE;
1251
1252         haystack_len = strlen(haystack);
1253         needle_len   = strlen(needle);
1254
1255         if (haystack_len < needle_len || needle_len == 0)
1256                 return NULL;
1257
1258         while (haystack_len >= needle_len) {
1259                 if (!in_squote && !in_dquote &&
1260                     !strncmp(haystack, needle, needle_len))
1261                         return (gchar *)haystack;
1262
1263                 /* 'foo"bar"' -> foo"bar"
1264                    "foo'bar'" -> foo'bar' */
1265                 if (*haystack == '\'') {
1266                         if (in_squote)
1267                                 in_squote = FALSE;
1268                         else if (!in_dquote)
1269                                 in_squote = TRUE;
1270                 } else if (*haystack == '\"') {
1271                         if (in_dquote)
1272                                 in_dquote = FALSE;
1273                         else if (!in_squote)
1274                                 in_dquote = TRUE;
1275                 }
1276
1277                 haystack++;
1278                 haystack_len--;
1279         }
1280
1281         return NULL;
1282 }
1283
1284 gchar *strchr_parenthesis_close(const gchar *str, gchar op, gchar cl)
1285 {
1286         const gchar *p;
1287         gchar quote_chr = '"';
1288         gint in_brace;
1289         gboolean in_quote = FALSE;
1290
1291         p = str;
1292
1293         if ((p = strchr_with_skip_quote(p, quote_chr, op))) {
1294                 p++;
1295                 in_brace = 1;
1296                 while (*p) {
1297                         if (*p == op && !in_quote)
1298                                 in_brace++;
1299                         else if (*p == cl && !in_quote)
1300                                 in_brace--;
1301                         else if (*p == quote_chr)
1302                                 in_quote ^= TRUE;
1303
1304                         if (in_brace == 0)
1305                                 return (gchar *)p;
1306
1307                         p++;
1308                 }
1309         }
1310
1311         return NULL;
1312 }
1313
1314 gchar **strsplit_parenthesis(const gchar *str, gchar op, gchar cl,
1315                              gint max_tokens)
1316 {
1317         GSList *string_list = NULL, *slist;
1318         gchar **str_array;
1319         const gchar *s_op, *s_cl;
1320         guint i, n = 1;
1321
1322         g_return_val_if_fail(str != NULL, NULL);
1323
1324         if (max_tokens < 1)
1325                 max_tokens = G_MAXINT;
1326
1327         s_op = strchr_with_skip_quote(str, '"', op);
1328         if (!s_op) return NULL;
1329         str = s_op;
1330         s_cl = strchr_parenthesis_close(str, op, cl);
1331         if (s_cl) {
1332                 do {
1333                         guint len;
1334                         gchar *new_string;
1335
1336                         str++;
1337                         len = s_cl - str;
1338                         new_string = g_new(gchar, len + 1);
1339                         strncpy(new_string, str, len);
1340                         new_string[len] = 0;
1341                         string_list = g_slist_prepend(string_list, new_string);
1342                         n++;
1343                         str = s_cl + 1;
1344
1345                         while (*str && g_ascii_isspace(*str)) str++;
1346                         if (*str != op) {
1347                                 string_list = g_slist_prepend(string_list,
1348                                                               g_strdup(""));
1349                                 n++;
1350                                 s_op = strchr_with_skip_quote(str, '"', op);
1351                                 if (!--max_tokens || !s_op) break;
1352                                 str = s_op;
1353                         } else
1354                                 s_op = str;
1355                         s_cl = strchr_parenthesis_close(str, op, cl);
1356                 } while (--max_tokens && s_cl);
1357         }
1358
1359         str_array = g_new(gchar*, n);
1360
1361         i = n - 1;
1362
1363         str_array[i--] = NULL;
1364         for (slist = string_list; slist; slist = slist->next)
1365                 str_array[i--] = slist->data;
1366
1367         g_slist_free(string_list);
1368
1369         return str_array;
1370 }
1371
1372 gchar **strsplit_with_quote(const gchar *str, const gchar *delim,
1373                             gint max_tokens)
1374 {
1375         GSList *string_list = NULL, *slist;
1376         gchar **str_array, *s, *new_str;
1377         guint i, n = 1, len;
1378
1379         g_return_val_if_fail(str != NULL, NULL);
1380         g_return_val_if_fail(delim != NULL, NULL);
1381
1382         if (max_tokens < 1)
1383                 max_tokens = G_MAXINT;
1384
1385         s = strstr_with_skip_quote(str, delim);
1386         if (s) {
1387                 guint delimiter_len = strlen(delim);
1388
1389                 do {
1390                         len = s - str;
1391                         new_str = g_strndup(str, len);
1392
1393                         if (new_str[0] == '\'' || new_str[0] == '\"') {
1394                                 if (new_str[len - 1] == new_str[0]) {
1395                                         new_str[len - 1] = '\0';
1396                                         memmove(new_str, new_str + 1, len - 1);
1397                                 }
1398                         }
1399                         string_list = g_slist_prepend(string_list, new_str);
1400                         n++;
1401                         str = s + delimiter_len;
1402                         s = strstr_with_skip_quote(str, delim);
1403                 } while (--max_tokens && s);
1404         }
1405
1406         if (*str) {
1407                 new_str = g_strdup(str);
1408                 if (new_str[0] == '\'' || new_str[0] == '\"') {
1409                         len = strlen(str);
1410                         if (new_str[len - 1] == new_str[0]) {
1411                                 new_str[len - 1] = '\0';
1412                                 memmove(new_str, new_str + 1, len - 1);
1413                         }
1414                 }
1415                 string_list = g_slist_prepend(string_list, new_str);
1416                 n++;
1417         }
1418
1419         str_array = g_new(gchar*, n);
1420
1421         i = n - 1;
1422
1423         str_array[i--] = NULL;
1424         for (slist = string_list; slist; slist = slist->next)
1425                 str_array[i--] = slist->data;
1426
1427         g_slist_free(string_list);
1428
1429         return str_array;
1430 }
1431
1432 gchar *get_abbrev_newsgroup_name(const gchar *group, gint len)
1433 {
1434         gchar *abbrev_group;
1435         gchar *ap;
1436         const gchar *p = group;
1437         const gchar *last;
1438
1439         g_return_val_if_fail(group != NULL, NULL);
1440
1441         last = group + strlen(group);
1442         abbrev_group = ap = g_malloc(strlen(group) + 1);
1443
1444         while (*p) {
1445                 while (*p == '.')
1446                         *ap++ = *p++;
1447                 if ((ap - abbrev_group) + (last - p) > len && strchr(p, '.')) {
1448                         *ap++ = *p++;
1449                         while (*p != '.') p++;
1450                 } else {
1451                         strcpy(ap, p);
1452                         return abbrev_group;
1453                 }
1454         }
1455
1456         *ap = '\0';
1457         return abbrev_group;
1458 }
1459
1460 gchar *trim_string(const gchar *str, gint len)
1461 {
1462         const gchar *p = str;
1463         gint mb_len;
1464         gchar *new_str;
1465         gint new_len = 0;
1466
1467         if (!str) return NULL;
1468         if (strlen(str) <= len)
1469                 return g_strdup(str);
1470         if (g_utf8_validate(str, -1, NULL) == FALSE)
1471                 return g_strdup(str);
1472
1473         while (*p != '\0') {
1474                 mb_len = g_utf8_skip[*(guchar *)p];
1475                 if (mb_len == 0)
1476                         break;
1477                 else if (new_len + mb_len > len)
1478                         break;
1479
1480                 new_len += mb_len;
1481                 p += mb_len;
1482         }
1483
1484         Xstrndup_a(new_str, str, new_len, return g_strdup(str));
1485         return g_strconcat(new_str, "...", NULL);
1486 }
1487
1488 GList *uri_list_extract_filenames(const gchar *uri_list)
1489 {
1490         GList *result = NULL;
1491         const gchar *p, *q;
1492         gchar *escaped_utf8uri;
1493
1494         p = uri_list;
1495
1496         while (p) {
1497                 if (*p != '#') {
1498                         while (g_ascii_isspace(*p)) p++;
1499                         if (!strncmp(p, "file:", 5)) {
1500                                 q = p;
1501                                 q += 5;
1502                                 while (*q && *q != '\n' && *q != '\r') q++;
1503
1504                                 if (q > p) {
1505                                         gchar *file, *locale_file = NULL;
1506                                         q--;
1507                                         while (q > p && g_ascii_isspace(*q))
1508                                                 q--;
1509                                         Xalloca(escaped_utf8uri, q - p + 2,
1510                                                 return result);
1511                                         Xalloca(file, q - p + 2,
1512                                                 return result);
1513                                         *file = '\0';
1514                                         strncpy(escaped_utf8uri, p, q - p + 1);
1515                                         escaped_utf8uri[q - p + 1] = '\0';
1516                                         decode_uri(file, escaped_utf8uri);
1517                     /*
1518                      * g_filename_from_uri() rejects escaped/locale encoded uri
1519                      * string which come from Nautilus.
1520                      */
1521                                         if (g_utf8_validate(file, -1, NULL))
1522                                                 locale_file
1523                                                         = conv_codeset_strdup(
1524                                                                 file + 5,
1525                                                                 CS_UTF_8,
1526                                                                 conv_get_locale_charset_str());
1527                                         if (!locale_file)
1528                                                 locale_file = g_strdup(file + 5);
1529                                         result = g_list_append(result, locale_file);
1530                                 }
1531                         }
1532                 }
1533                 p = strchr(p, '\n');
1534                 if (p) p++;
1535         }
1536
1537         return result;
1538 }
1539
1540 /* Converts two-digit hexadecimal to decimal.  Used for unescaping escaped
1541  * characters
1542  */
1543 static gint axtoi(const gchar *hexstr)
1544 {
1545         gint hi, lo, result;
1546
1547         hi = hexstr[0];
1548         if ('0' <= hi && hi <= '9') {
1549                 hi -= '0';
1550         } else
1551                 if ('a' <= hi && hi <= 'f') {
1552                         hi -= ('a' - 10);
1553                 } else
1554                         if ('A' <= hi && hi <= 'F') {
1555                                 hi -= ('A' - 10);
1556                         }
1557
1558         lo = hexstr[1];
1559         if ('0' <= lo && lo <= '9') {
1560                 lo -= '0';
1561         } else
1562                 if ('a' <= lo && lo <= 'f') {
1563                         lo -= ('a'-10);
1564                 } else
1565                         if ('A' <= lo && lo <= 'F') {
1566                                 lo -= ('A' - 10);
1567                         }
1568         result = lo + (16 * hi);
1569         return result;
1570 }
1571
1572 gboolean is_uri_string(const gchar *str)
1573 {
1574         while (str && *str && g_ascii_isspace(*str))
1575                 str++;
1576         return (g_ascii_strncasecmp(str, "http://", 7) == 0 ||
1577                 g_ascii_strncasecmp(str, "https://", 8) == 0 ||
1578                 g_ascii_strncasecmp(str, "ftp://", 6) == 0 ||
1579                 g_ascii_strncasecmp(str, "www.", 4) == 0);
1580 }
1581
1582 gchar *get_uri_path(const gchar *uri)
1583 {
1584         while (uri && *uri && g_ascii_isspace(*uri))
1585                 uri++;
1586         if (g_ascii_strncasecmp(uri, "http://", 7) == 0)
1587                 return (gchar *)(uri + 7);
1588         else if (g_ascii_strncasecmp(uri, "https://", 8) == 0)
1589                 return (gchar *)(uri + 8);
1590         else if (g_ascii_strncasecmp(uri, "ftp://", 6) == 0)
1591                 return (gchar *)(uri + 6);
1592         else
1593                 return (gchar *)uri;
1594 }
1595
1596 gint get_uri_len(const gchar *str)
1597 {
1598         const gchar *p;
1599
1600         if (is_uri_string(str)) {
1601                 for (p = str; *p != '\0'; p++) {
1602                         if (!g_ascii_isgraph(*p) || strchr("()<>\"", *p))
1603                                 break;
1604                 }
1605                 return p - str;
1606         }
1607
1608         return 0;
1609 }
1610
1611 /* Decodes URL-Encoded strings (i.e. strings in which spaces are replaced by
1612  * plusses, and escape characters are used)
1613  */
1614 void decode_uri(gchar *decoded_uri, const gchar *encoded_uri)
1615 {
1616         gchar *dec = decoded_uri;
1617         const gchar *enc = encoded_uri;
1618
1619         while (*enc) {
1620                 if (*enc == '%') {
1621                         enc++;
1622                         if (isxdigit((guchar)enc[0]) &&
1623                             isxdigit((guchar)enc[1])) {
1624                                 *dec = axtoi(enc);
1625                                 dec++;
1626                                 enc += 2;
1627                         }
1628                 } else {
1629                         if (*enc == '+')
1630                                 *dec = ' ';
1631                         else
1632                                 *dec = *enc;
1633                         dec++;
1634                         enc++;
1635                 }
1636         }
1637
1638         *dec = '\0';
1639 }
1640
1641 gint scan_mailto_url(const gchar *mailto, gchar **to, gchar **cc, gchar **bcc,
1642                      gchar **subject, gchar **body, gchar **attach)
1643 {
1644         gchar *tmp_mailto;
1645         gchar *p;
1646         const gchar *forbidden_uris[] = { ".gnupg/",
1647                                           "/etc/passwd",
1648                                           "/etc/shadow",
1649                                           NULL };
1650
1651         Xstrdup_a(tmp_mailto, mailto, return -1);
1652
1653         if (!strncmp(tmp_mailto, "mailto:", 7))
1654                 tmp_mailto += 7;
1655
1656         p = strchr(tmp_mailto, '?');
1657         if (p) {
1658                 *p = '\0';
1659                 p++;
1660         }
1661
1662         if (to && !*to)
1663                 *to = g_strdup(tmp_mailto);
1664
1665         while (p) {
1666                 gchar *field, *value;
1667
1668                 field = p;
1669
1670                 p = strchr(p, '=');
1671                 if (!p) break;
1672                 *p = '\0';
1673                 p++;
1674
1675                 value = p;
1676
1677                 p = strchr(p, '&');
1678                 if (p) {
1679                         *p = '\0';
1680                         p++;
1681                 }
1682
1683                 if (*value == '\0') continue;
1684
1685                 if (cc && !*cc && !g_ascii_strcasecmp(field, "cc")) {
1686                         *cc = g_strdup(value);
1687                 } else if (bcc && !*bcc && !g_ascii_strcasecmp(field, "bcc")) {
1688                         *bcc = g_strdup(value);
1689                 } else if (subject && !*subject &&
1690                            !g_ascii_strcasecmp(field, "subject")) {
1691                         *subject = g_malloc(strlen(value) + 1);
1692                         decode_uri(*subject, value);
1693                 } else if (body && !*body && !g_ascii_strcasecmp(field, "body")) {
1694                         *body = g_malloc(strlen(value) + 1);
1695                         decode_uri(*body, value);
1696                 } else if (attach && !*attach && !g_ascii_strcasecmp(field, "attach")) {
1697                         int i = 0;
1698                         *attach = g_malloc(strlen(value) + 1);
1699                         decode_uri(*attach, value);
1700                         for (; forbidden_uris[i]; i++) {
1701                                 if (strstr(*attach, forbidden_uris[i])) {
1702                                         printf("Refusing to attach '%s', potential private data leak\n",
1703                                                         *attach);
1704                                         g_free(*attach);
1705                                         *attach = NULL;
1706                                         break;
1707                                 }
1708                         }
1709                 }
1710         }
1711
1712         return 0;
1713 }
1714
1715
1716 #ifdef G_OS_WIN32
1717 #include <windows.h>
1718 #ifndef CSIDL_APPDATA
1719 #define CSIDL_APPDATA 0x001a
1720 #endif
1721 #ifndef CSIDL_LOCAL_APPDATA
1722 #define CSIDL_LOCAL_APPDATA 0x001c
1723 #endif
1724 #ifndef CSIDL_FLAG_CREATE
1725 #define CSIDL_FLAG_CREATE 0x8000
1726 #endif
1727 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
1728
1729 #define RTLD_LAZY 0
1730 const char *
1731 w32_strerror (int w32_errno)
1732 {
1733   static char strerr[256];
1734   int ec = (int)GetLastError ();
1735
1736   if (w32_errno == 0)
1737     w32_errno = ec;
1738   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, w32_errno,
1739                  MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
1740                  strerr, DIM (strerr)-1, NULL);
1741   return strerr;
1742 }
1743
1744 static __inline__ void *
1745 dlopen (const char * name, int flag)
1746 {
1747   void * hd = LoadLibrary (name);
1748   return hd;
1749 }
1750
1751 static __inline__ void *
1752 dlsym (void * hd, const char * sym)
1753 {
1754   if (hd && sym)
1755     {
1756       void * fnc = GetProcAddress (hd, sym);
1757       if (!fnc)
1758         return NULL;
1759       return fnc;
1760     }
1761   return NULL;
1762 }
1763
1764
1765 static __inline__ const char *
1766 dlerror (void)
1767 {
1768   return w32_strerror (0);
1769 }
1770
1771
1772 static __inline__ int
1773 dlclose (void * hd)
1774 {
1775   if (hd)
1776     {
1777       FreeLibrary (hd);
1778       return 0;
1779     }
1780   return -1;
1781 }
1782
1783 static HRESULT
1784 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
1785 {
1786   static int initialized;
1787   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
1788
1789   if (!initialized)
1790     {
1791       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
1792       void *handle;
1793       int i;
1794
1795       initialized = 1;
1796
1797       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
1798         {
1799           handle = dlopen (dllnames[i], RTLD_LAZY);
1800           if (handle)
1801             {
1802               func = dlsym (handle, "SHGetFolderPathA");
1803               if (!func)
1804                 {
1805                   dlclose (handle);
1806                   handle = NULL;
1807                 }
1808             }
1809         }
1810     }
1811
1812   if (func)
1813     return func (a,b,c,d,e);
1814   else
1815     return -1;
1816 }
1817
1818 /* Returns a static string with the directroy from which the module
1819    has been loaded.  Returns an empty string on error. */
1820 static char *w32_get_module_dir(void)
1821 {
1822         static char *moddir;
1823
1824         if (!moddir) {
1825                 char name[MAX_PATH+10];
1826                 char *p;
1827
1828                 if ( !GetModuleFileNameA (0, name, sizeof (name)-10) )
1829                         *name = 0;
1830                 else {
1831                         p = strrchr (name, '\\');
1832                         if (p)
1833                                 *p = 0;
1834                         else
1835                                 *name = 0;
1836                 }
1837                 moddir = g_strdup (name);
1838         }
1839         return moddir;
1840 }
1841 #endif /* G_OS_WIN32 */
1842
1843 /* Return a static string with the locale dir. */
1844 const gchar *get_locale_dir(void)
1845 {
1846         static gchar *loc_dir;
1847
1848 #ifdef G_OS_WIN32
1849         if (!loc_dir)
1850                 loc_dir = g_strconcat(w32_get_module_dir(), G_DIR_SEPARATOR_S,
1851                                       "\\share\\locale", NULL);
1852 #endif
1853         if (!loc_dir)
1854                 loc_dir = LOCALEDIR;
1855         
1856         return loc_dir;
1857 }
1858
1859
1860 const gchar *get_home_dir(void)
1861 {
1862 #ifdef G_OS_WIN32
1863         static char home_dir[MAX_PATH] = "";
1864
1865         if (home_dir[0] == '\0') {
1866                 if (w32_shgetfolderpath
1867                             (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
1868                              NULL, 0, home_dir) < 0)
1869                                 strcpy (home_dir, "C:\\Sylpheed");
1870         }
1871         return home_dir;
1872 #else
1873         static const gchar *homeenv = NULL;
1874
1875         if (homeenv)
1876                 return homeenv;
1877
1878         if (!homeenv && g_getenv("HOME") != NULL)
1879                 homeenv = g_strdup(g_getenv("HOME"));
1880         if (!homeenv)
1881                 homeenv = g_get_home_dir();
1882
1883         return homeenv;
1884 #endif
1885 }
1886
1887 const gchar *get_rc_dir(void)
1888 {
1889         static gchar *rc_dir = NULL;
1890
1891         if (!rc_dir)
1892                 rc_dir = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
1893                                      RC_DIR, NULL);
1894
1895         return rc_dir;
1896 }
1897
1898 const gchar *get_mail_base_dir(void)
1899 {
1900 #ifdef G_OS_WIN32
1901         static gchar *mail_base_dir = NULL;
1902
1903         if (!mail_base_dir)
1904                 mail_base_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1905                                             "Mailboxes", NULL);
1906
1907         return mail_base_dir;
1908 #else
1909         return get_home_dir();
1910 #endif
1911 }
1912
1913 const gchar *get_news_cache_dir(void)
1914 {
1915         static gchar *news_cache_dir = NULL;
1916
1917         if (!news_cache_dir)
1918                 news_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1919                                              NEWS_CACHE_DIR, NULL);
1920
1921         return news_cache_dir;
1922 }
1923
1924 const gchar *get_imap_cache_dir(void)
1925 {
1926         static gchar *imap_cache_dir = NULL;
1927
1928         if (!imap_cache_dir)
1929                 imap_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1930                                              IMAP_CACHE_DIR, NULL);
1931
1932         return imap_cache_dir;
1933 }
1934
1935 const gchar *get_mbox_cache_dir(void)
1936 {
1937         static gchar *mbox_cache_dir = NULL;
1938
1939         if (!mbox_cache_dir)
1940                 mbox_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1941                                              MBOX_CACHE_DIR, NULL);
1942
1943         return mbox_cache_dir;
1944 }
1945
1946 const gchar *get_mime_tmp_dir(void)
1947 {
1948         static gchar *mime_tmp_dir = NULL;
1949
1950         if (!mime_tmp_dir)
1951                 mime_tmp_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1952                                            MIME_TMP_DIR, NULL);
1953
1954         return mime_tmp_dir;
1955 }
1956
1957 const gchar *get_template_dir(void)
1958 {
1959         static gchar *template_dir = NULL;
1960
1961         if (!template_dir)
1962                 template_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1963                                            TEMPLATE_DIR, NULL);
1964
1965         return template_dir;
1966 }
1967
1968 const gchar *get_header_cache_dir(void)
1969 {
1970         static gchar *header_dir = NULL;
1971
1972         if (!header_dir)
1973                 header_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1974                                          HEADER_CACHE_DIR, NULL);
1975
1976         return header_dir;
1977 }
1978
1979 /* Return the default directory for Plugins. */
1980 const gchar *get_plugin_dir(void)
1981 {
1982 #ifdef G_OS_WIN32
1983         static gchar *plugin_dir = NULL;
1984
1985         if (!plugin_dir)
1986                 plugin_dir = g_strconcat(w32_get_module_dir(),
1987                                          "\\lib\\claws-mail\\plugins\\",
1988                                          NULL);
1989         return plugin_dir;
1990 #else
1991         if (is_dir_exist(PLUGINDIR))
1992                 return PLUGINDIR;
1993         else {
1994                 static gchar *plugin_dir = NULL;
1995                 if (!plugin_dir)
1996                         plugin_dir = g_strconcat(get_rc_dir(), 
1997                                 G_DIR_SEPARATOR_S, "plugins", 
1998                                 G_DIR_SEPARATOR_S, NULL);
1999                 return plugin_dir;                      
2000         }
2001 #endif
2002 }
2003
2004 const gchar *get_tmp_dir(void)
2005 {
2006         static gchar *tmp_dir = NULL;
2007
2008         if (!tmp_dir)
2009                 tmp_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
2010                                       TMP_DIR, NULL);
2011
2012         return tmp_dir;
2013 }
2014
2015 gchar *get_tmp_file(void)
2016 {
2017         gchar *tmp_file;
2018         static guint32 id = 0;
2019
2020         tmp_file = g_strdup_printf("%s%ctmpfile.%08x",
2021                                    get_tmp_dir(), G_DIR_SEPARATOR, id++);
2022
2023         return tmp_file;
2024 }
2025
2026 const gchar *get_domain_name(void)
2027 {
2028 #ifdef G_OS_UNIX
2029         static gchar *domain_name = NULL;
2030
2031         if (!domain_name) {
2032                 struct hostent *hp;
2033                 struct utsname uts;
2034
2035                 if (uname(&uts) < 0) {
2036                         perror("uname");
2037                         domain_name = "unknown";
2038                 } else {
2039                         if ((hp = my_gethostbyname(uts.nodename)) == NULL) {
2040                                 perror("gethostbyname");
2041                                 domain_name = g_strdup(uts.nodename);
2042                         } else {
2043                                 domain_name = g_strdup(hp->h_name);
2044                         }
2045                 }
2046
2047                 debug_print("domain name = %s\n", domain_name);
2048         }
2049
2050         return domain_name;
2051 #else
2052         return "unknown";
2053 #endif
2054 }
2055
2056 off_t get_file_size(const gchar *file)
2057 {
2058         struct stat s;
2059
2060         if (g_stat(file, &s) < 0) {
2061                 FILE_OP_ERROR(file, "stat");
2062                 return -1;
2063         }
2064
2065         return s.st_size;
2066 }
2067
2068 time_t get_file_mtime(const gchar *file)
2069 {
2070         struct stat s;
2071
2072         if (g_stat(file, &s) < 0) {
2073                 FILE_OP_ERROR(file, "stat");
2074                 return -1;
2075         }
2076
2077         return s.st_mtime;
2078 }
2079
2080 off_t get_file_size_as_crlf(const gchar *file)
2081 {
2082         FILE *fp;
2083         off_t size = 0;
2084         gchar buf[BUFFSIZE];
2085
2086         if ((fp = g_fopen(file, "rb")) == NULL) {
2087                 FILE_OP_ERROR(file, "fopen");
2088                 return -1;
2089         }
2090
2091         while (fgets(buf, sizeof(buf), fp) != NULL) {
2092                 strretchomp(buf);
2093                 size += strlen(buf) + 2;
2094         }
2095
2096         if (ferror(fp)) {
2097                 FILE_OP_ERROR(file, "fgets");
2098                 size = -1;
2099         }
2100
2101         fclose(fp);
2102
2103         return size;
2104 }
2105
2106 off_t get_left_file_size(FILE *fp)
2107 {
2108         glong pos;
2109         glong end;
2110         off_t size;
2111
2112         if ((pos = ftell(fp)) < 0) {
2113                 perror("ftell");
2114                 return -1;
2115         }
2116         if (fseek(fp, 0L, SEEK_END) < 0) {
2117                 perror("fseek");
2118                 return -1;
2119         }
2120         if ((end = ftell(fp)) < 0) {
2121                 perror("fseek");
2122                 return -1;
2123         }
2124         size = end - pos;
2125         if (fseek(fp, pos, SEEK_SET) < 0) {
2126                 perror("fseek");
2127                 return -1;
2128         }
2129
2130         return size;
2131 }
2132
2133 gboolean file_exist(const gchar *file, gboolean allow_fifo)
2134 {
2135         struct stat s;
2136
2137         if (file == NULL)
2138                 return FALSE;
2139
2140         if (g_stat(file, &s) < 0) {
2141                 if (ENOENT != errno) FILE_OP_ERROR(file, "stat");
2142                 return FALSE;
2143         }
2144
2145         if (S_ISREG(s.st_mode) || (allow_fifo && S_ISFIFO(s.st_mode)))
2146                 return TRUE;
2147
2148         return FALSE;
2149 }
2150
2151
2152 /* Test on whether FILE is a relative file name. This is
2153  * straightforward for Unix but more complex for Windows. */
2154 gboolean is_relative_filename(const gchar *file)
2155 {
2156         if (!file)
2157                 return TRUE;
2158 #ifdef G_OS_WIN32
2159         if ( *file == '\\' && file[1] == '\\' && strchr (file+2, '\\') )
2160                 return FALSE; /* Prefixed with a hostname - this can't
2161                                * be a relative name. */
2162
2163         if ( ((*file >= 'a' && *file <= 'z')
2164               || (*file >= 'A' && *file <= 'Z'))
2165              && file[1] == ':')
2166                 file += 2;  /* Skip drive letter. */
2167
2168         return !(*file == '\\' || *file == '/');
2169 #else
2170         return !(*file == G_DIR_SEPARATOR);
2171 #endif
2172 }
2173
2174
2175 gboolean is_dir_exist(const gchar *dir)
2176 {
2177         if (dir == NULL)
2178                 return FALSE;
2179
2180         return g_file_test(dir, G_FILE_TEST_IS_DIR);
2181 }
2182
2183 gboolean is_file_entry_exist(const gchar *file)
2184 {
2185         if (file == NULL)
2186                 return FALSE;
2187
2188         return g_file_test(file, G_FILE_TEST_EXISTS);
2189 }
2190
2191 gboolean dirent_is_regular_file(struct dirent *d)
2192 {
2193 #ifdef HAVE_DIRENT_D_TYPE
2194         if (d->d_type == DT_REG)
2195                 return TRUE;
2196         else if (d->d_type != DT_UNKNOWN)
2197                 return FALSE;
2198 #endif
2199
2200         return g_file_test(d->d_name, G_FILE_TEST_IS_REGULAR);
2201 }
2202
2203 gboolean dirent_is_directory(struct dirent *d)
2204 {
2205 #ifdef HAVE_DIRENT_D_TYPE
2206         if (d->d_type == DT_DIR)
2207                 return TRUE;
2208         else if (d->d_type != DT_UNKNOWN)
2209                 return FALSE;
2210 #endif
2211
2212         return g_file_test(d->d_name, G_FILE_TEST_IS_DIR);
2213 }
2214
2215 gint change_dir(const gchar *dir)
2216 {
2217         gchar *prevdir = NULL;
2218
2219         if (debug_mode)
2220                 prevdir = g_get_current_dir();
2221
2222         if (g_chdir(dir) < 0) {
2223                 FILE_OP_ERROR(dir, "chdir");
2224                 if (debug_mode) g_free(prevdir);
2225                 return -1;
2226         } else if (debug_mode) {
2227                 gchar *cwd;
2228
2229                 cwd = g_get_current_dir();
2230                 if (strcmp(prevdir, cwd) != 0)
2231                         g_print("current dir: %s\n", cwd);
2232                 g_free(cwd);
2233                 g_free(prevdir);
2234         }
2235
2236         return 0;
2237 }
2238
2239 gint make_dir(const gchar *dir)
2240 {
2241         if (g_mkdir(dir, S_IRWXU) < 0) {
2242                 FILE_OP_ERROR(dir, "mkdir");
2243                 return -1;
2244         }
2245         if (g_chmod(dir, S_IRWXU) < 0)
2246                 FILE_OP_ERROR(dir, "chmod");
2247
2248         return 0;
2249 }
2250
2251 gint make_dir_hier(const gchar *dir)
2252 {
2253         gchar *parent_dir;
2254         const gchar *p;
2255
2256         for (p = dir; (p = strchr(p, G_DIR_SEPARATOR)) != NULL; p++) {
2257                 parent_dir = g_strndup(dir, p - dir);
2258                 if (*parent_dir != '\0') {
2259                         if (!is_dir_exist(parent_dir)) {
2260                                 if (make_dir(parent_dir) < 0) {
2261                                         g_free(parent_dir);
2262                                         return -1;
2263                                 }
2264                         }
2265                 }
2266                 g_free(parent_dir);
2267         }
2268
2269         if (!is_dir_exist(dir)) {
2270                 if (make_dir(dir) < 0)
2271                         return -1;
2272         }
2273
2274         return 0;
2275 }
2276
2277 gint remove_all_files(const gchar *dir)
2278 {
2279         GDir *dp;
2280         const gchar *dir_name;
2281         gchar *prev_dir;
2282
2283         prev_dir = g_get_current_dir();
2284
2285         if (g_chdir(dir) < 0) {
2286                 FILE_OP_ERROR(dir, "chdir");
2287                 g_free(prev_dir);
2288                 return -1;
2289         }
2290
2291         if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
2292                 g_warning("failed to open directory: %s\n", dir);
2293                 g_free(prev_dir);
2294                 return -1;
2295         }
2296
2297         while ((dir_name = g_dir_read_name(dp)) != NULL) {
2298                 if (g_unlink(dir_name) < 0)
2299                         FILE_OP_ERROR(dir_name, "unlink");
2300         }
2301
2302         g_dir_close(dp);
2303
2304         if (g_chdir(prev_dir) < 0) {
2305                 FILE_OP_ERROR(prev_dir, "chdir");
2306                 g_free(prev_dir);
2307                 return -1;
2308         }
2309
2310         g_free(prev_dir);
2311
2312         return 0;
2313 }
2314
2315 gint remove_numbered_files(const gchar *dir, guint first, guint last)
2316 {
2317         GDir *dp;
2318         const gchar *dir_name;
2319         gchar *prev_dir;
2320         gint file_no;
2321
2322         prev_dir = g_get_current_dir();
2323
2324         if (g_chdir(dir) < 0) {
2325                 FILE_OP_ERROR(dir, "chdir");
2326                 g_free(prev_dir);
2327                 return -1;
2328         }
2329
2330         if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
2331                 g_warning("failed to open directory: %s\n", dir);
2332                 g_free(prev_dir);
2333                 return -1;
2334         }
2335
2336         while ((dir_name = g_dir_read_name(dp)) != NULL) {
2337                 file_no = to_number(dir_name);
2338                 if (file_no > 0 && first <= file_no && file_no <= last) {
2339                         if (is_dir_exist(dir_name))
2340                                 continue;
2341                         if (g_unlink(dir_name) < 0)
2342                                 FILE_OP_ERROR(dir_name, "unlink");
2343                 }
2344         }
2345
2346         g_dir_close(dp);
2347
2348         if (g_chdir(prev_dir) < 0) {
2349                 FILE_OP_ERROR(prev_dir, "chdir");
2350                 g_free(prev_dir);
2351                 return -1;
2352         }
2353
2354         g_free(prev_dir);
2355
2356         return 0;
2357 }
2358
2359 gint remove_numbered_files_not_in_list(const gchar *dir, GSList *numberlist)
2360 {
2361         GDir *dp;
2362         const gchar *dir_name;
2363         gchar *prev_dir;
2364         gint file_no;
2365
2366         prev_dir = g_get_current_dir();
2367
2368         if (g_chdir(dir) < 0) {
2369                 FILE_OP_ERROR(dir, "chdir");
2370                 g_free(prev_dir);
2371                 return -1;
2372         }
2373
2374         if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
2375                 FILE_OP_ERROR(dir, "opendir");
2376                 g_free(prev_dir);
2377                 return -1;
2378         }
2379
2380         while ((dir_name = g_dir_read_name(dp)) != NULL) {
2381                 file_no = to_number(dir_name);
2382                 if (file_no > 0 && (g_slist_find(numberlist, GINT_TO_POINTER(file_no)) == NULL)) {
2383                         debug_print("removing unwanted file %d from %s\n", file_no, dir);
2384                         if (is_dir_exist(dir_name))
2385                                 continue;
2386                         if (g_unlink(dir_name) < 0)
2387                                 FILE_OP_ERROR(dir_name, "unlink");
2388                 }
2389         }
2390
2391         g_dir_close(dp);
2392
2393         if (g_chdir(prev_dir) < 0) {
2394                 FILE_OP_ERROR(prev_dir, "chdir");
2395                 g_free(prev_dir);
2396                 return -1;
2397         }
2398
2399         g_free(prev_dir);
2400
2401         return 0;
2402 }
2403
2404 gint remove_all_numbered_files(const gchar *dir)
2405 {
2406         return remove_numbered_files(dir, 0, UINT_MAX);
2407 }
2408
2409 gint remove_expired_files(const gchar *dir, guint hours)
2410 {
2411         GDir *dp;
2412         const gchar *dir_name;
2413         struct stat s;
2414         gchar *prev_dir;
2415         gint file_no;
2416         time_t mtime, now, expire_time;
2417
2418         prev_dir = g_get_current_dir();
2419
2420         if (g_chdir(dir) < 0) {
2421                 FILE_OP_ERROR(dir, "chdir");
2422                 g_free(prev_dir);
2423                 return -1;
2424         }
2425
2426         if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
2427                 g_warning("failed to open directory: %s\n", dir);
2428                 g_free(prev_dir);
2429                 return -1;
2430         }
2431
2432         now = time(NULL);
2433         expire_time = hours * 60 * 60;
2434
2435         while ((dir_name = g_dir_read_name(dp)) != NULL) {
2436                 file_no = to_number(dir_name);
2437                 if (file_no > 0) {
2438                         if (g_stat(dir_name, &s) < 0) {
2439                                 FILE_OP_ERROR(dir_name, "stat");
2440                                 continue;
2441                         }
2442                         if (S_ISDIR(s.st_mode))
2443                                 continue;
2444                         mtime = MAX(s.st_mtime, s.st_atime);
2445                         if (now - mtime > expire_time) {
2446                                 if (g_unlink(dir_name) < 0)
2447                                         FILE_OP_ERROR(dir_name, "unlink");
2448                         }
2449                 }
2450         }
2451
2452         g_dir_close(dp);
2453
2454         if (g_chdir(prev_dir) < 0) {
2455                 FILE_OP_ERROR(prev_dir, "chdir");
2456                 g_free(prev_dir);
2457                 return -1;
2458         }
2459
2460         g_free(prev_dir);
2461
2462         return 0;
2463 }
2464
2465 gint remove_dir_recursive(const gchar *dir)
2466 {
2467         struct stat s;
2468         GDir *dp;
2469         const gchar *dir_name;
2470         gchar *prev_dir;
2471
2472         if (g_stat(dir, &s) < 0) {
2473                 FILE_OP_ERROR(dir, "stat");
2474                 if (ENOENT == errno) return 0;
2475                 return -1;
2476         }
2477
2478         if (!S_ISDIR(s.st_mode)) {
2479                 if (g_unlink(dir) < 0) {
2480                         FILE_OP_ERROR(dir, "unlink");
2481                         return -1;
2482                 }
2483
2484                 return 0;
2485         }
2486
2487         prev_dir = g_get_current_dir();
2488         /* g_print("prev_dir = %s\n", prev_dir); */
2489
2490         if (!path_cmp(prev_dir, dir)) {
2491                 g_free(prev_dir);
2492                 if (g_chdir("..") < 0) {
2493                         FILE_OP_ERROR(dir, "chdir");
2494                         return -1;
2495                 }
2496                 prev_dir = g_get_current_dir();
2497         }
2498
2499         if (g_chdir(dir) < 0) {
2500                 FILE_OP_ERROR(dir, "chdir");
2501                 g_free(prev_dir);
2502                 return -1;
2503         }
2504
2505         if ((dp = g_dir_open(".", 0, NULL)) == NULL) {
2506                 g_warning("failed to open directory: %s\n", dir);
2507                 g_chdir(prev_dir);
2508                 g_free(prev_dir);
2509                 return -1;
2510         }
2511
2512         /* remove all files in the directory */
2513         while ((dir_name = g_dir_read_name(dp)) != NULL) {
2514                 /* g_print("removing %s\n", dir_name); */
2515
2516                 if (is_dir_exist(dir_name)) {
2517                         if (remove_dir_recursive(dir_name) < 0) {
2518                                 g_warning("can't remove directory\n");
2519                                 return -1;
2520                         }
2521                 } else {
2522                         if (g_unlink(dir_name) < 0)
2523                                 FILE_OP_ERROR(dir_name, "unlink");
2524                 }
2525         }
2526
2527         g_dir_close(dp);
2528
2529         if (g_chdir(prev_dir) < 0) {
2530                 FILE_OP_ERROR(prev_dir, "chdir");
2531                 g_free(prev_dir);
2532                 return -1;
2533         }
2534
2535         g_free(prev_dir);
2536
2537         if (g_rmdir(dir) < 0) {
2538                 FILE_OP_ERROR(dir, "rmdir");
2539                 return -1;
2540         }
2541
2542         return 0;
2543 }
2544
2545 gint rename_force(const gchar *oldpath, const gchar *newpath)
2546 {
2547 #ifndef G_OS_UNIX
2548         if (!is_file_entry_exist(oldpath)) {
2549                 errno = ENOENT;
2550                 return -1;
2551         }
2552         if (is_file_exist(newpath)) {
2553                 if (g_unlink(newpath) < 0)
2554                         FILE_OP_ERROR(newpath, "unlink");
2555         }
2556 #endif
2557         return g_rename(oldpath, newpath);
2558 }
2559
2560 /*
2561  * Append src file body to the tail of dest file.
2562  * Now keep_backup has no effects.
2563  */
2564 gint append_file(const gchar *src, const gchar *dest, gboolean keep_backup)
2565 {
2566         FILE *src_fp, *dest_fp;
2567         gint n_read;
2568         gchar buf[BUFSIZ];
2569
2570         gboolean err = FALSE;
2571
2572         if ((src_fp = g_fopen(src, "rb")) == NULL) {
2573                 FILE_OP_ERROR(src, "fopen");
2574                 return -1;
2575         }
2576
2577         if ((dest_fp = g_fopen(dest, "ab")) == NULL) {
2578                 FILE_OP_ERROR(dest, "fopen");
2579                 fclose(src_fp);
2580                 return -1;
2581         }
2582
2583         if (change_file_mode_rw(dest_fp, dest) < 0) {
2584                 FILE_OP_ERROR(dest, "chmod");
2585                 g_warning("can't change file mode\n");
2586         }
2587
2588         while ((n_read = fread(buf, sizeof(gchar), sizeof(buf), src_fp)) > 0) {
2589                 if (n_read < sizeof(buf) && ferror(src_fp))
2590                         break;
2591                 if (fwrite(buf, 1, n_read, dest_fp) < n_read) {
2592                         g_warning("writing to %s failed.\n", dest);
2593                         fclose(dest_fp);
2594                         fclose(src_fp);
2595                         g_unlink(dest);
2596                         return -1;
2597                 }
2598         }
2599
2600         if (ferror(src_fp)) {
2601                 FILE_OP_ERROR(src, "fread");
2602                 err = TRUE;
2603         }
2604         fclose(src_fp);
2605         if (fclose(dest_fp) == EOF) {
2606                 FILE_OP_ERROR(dest, "fclose");
2607                 err = TRUE;
2608         }
2609
2610         if (err) {
2611                 g_unlink(dest);
2612                 return -1;
2613         }
2614
2615         return 0;
2616 }
2617
2618 gint copy_file(const gchar *src, const gchar *dest, gboolean keep_backup)
2619 {
2620         FILE *src_fp, *dest_fp;
2621         gint n_read;
2622         gchar buf[BUFSIZ];
2623         gchar *dest_bak = NULL;
2624         gboolean err = FALSE;
2625
2626         if ((src_fp = g_fopen(src, "rb")) == NULL) {
2627                 FILE_OP_ERROR(src, "fopen");
2628                 return -1;
2629         }
2630         if (is_file_exist(dest)) {
2631                 dest_bak = g_strconcat(dest, ".bak", NULL);
2632                 if (rename_force(dest, dest_bak) < 0) {
2633                         FILE_OP_ERROR(dest, "rename");
2634                         fclose(src_fp);
2635                         g_free(dest_bak);
2636                         return -1;
2637                 }
2638         }
2639
2640         if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
2641                 FILE_OP_ERROR(dest, "fopen");
2642                 fclose(src_fp);
2643                 if (dest_bak) {
2644                         if (rename_force(dest_bak, dest) < 0)
2645                                 FILE_OP_ERROR(dest_bak, "rename");
2646                         g_free(dest_bak);
2647                 }
2648                 return -1;
2649         }
2650
2651         if (change_file_mode_rw(dest_fp, dest) < 0) {
2652                 FILE_OP_ERROR(dest, "chmod");
2653                 g_warning("can't change file mode\n");
2654         }
2655
2656         while ((n_read = fread(buf, sizeof(gchar), sizeof(buf), src_fp)) > 0) {
2657                 if (n_read < sizeof(buf) && ferror(src_fp))
2658                         break;
2659                 if (fwrite(buf, 1, n_read, dest_fp) < n_read) {
2660                         g_warning("writing to %s failed.\n", dest);
2661                         fclose(dest_fp);
2662                         fclose(src_fp);
2663                         g_unlink(dest);
2664                         if (dest_bak) {
2665                                 if (rename_force(dest_bak, dest) < 0)
2666                                         FILE_OP_ERROR(dest_bak, "rename");
2667                                 g_free(dest_bak);
2668                         }
2669                         return -1;
2670                 }
2671         }
2672
2673         if (ferror(src_fp)) {
2674                 FILE_OP_ERROR(src, "fread");
2675                 err = TRUE;
2676         }
2677         fclose(src_fp);
2678         if (fclose(dest_fp) == EOF) {
2679                 FILE_OP_ERROR(dest, "fclose");
2680                 err = TRUE;
2681         }
2682
2683         if (err) {
2684                 g_unlink(dest);
2685                 if (dest_bak) {
2686                         if (rename_force(dest_bak, dest) < 0)
2687                                 FILE_OP_ERROR(dest_bak, "rename");
2688                         g_free(dest_bak);
2689                 }
2690                 return -1;
2691         }
2692
2693         if (keep_backup == FALSE && dest_bak)
2694                 g_unlink(dest_bak);
2695
2696         g_free(dest_bak);
2697
2698         return 0;
2699 }
2700
2701 gint move_file(const gchar *src, const gchar *dest, gboolean overwrite)
2702 {
2703         if (overwrite == FALSE && is_file_exist(dest)) {
2704                 g_warning("move_file(): file %s already exists.", dest);
2705                 return -1;
2706         }
2707
2708         if (rename_force(src, dest) == 0) return 0;
2709
2710         if (EXDEV != errno) {
2711                 FILE_OP_ERROR(src, "rename");
2712                 return -1;
2713         }
2714
2715         if (copy_file(src, dest, FALSE) < 0) return -1;
2716
2717         g_unlink(src);
2718
2719         return 0;
2720 }
2721
2722 gint copy_file_part_to_fp(FILE *fp, off_t offset, size_t length, FILE *dest_fp)
2723 {
2724         gint n_read;
2725         gint bytes_left, to_read;
2726         gchar buf[BUFSIZ];
2727
2728         if (fseek(fp, offset, SEEK_SET) < 0) {
2729                 perror("fseek");
2730                 return -1;
2731         }
2732
2733         bytes_left = length;
2734         to_read = MIN(bytes_left, sizeof(buf));
2735
2736         while ((n_read = fread(buf, sizeof(gchar), to_read, fp)) > 0) {
2737                 if (n_read < to_read && ferror(fp))
2738                         break;
2739                 if (fwrite(buf, 1, n_read, dest_fp) < n_read) {
2740                         return -1;
2741                 }
2742                 bytes_left -= n_read;
2743                 if (bytes_left == 0)
2744                         break;
2745                 to_read = MIN(bytes_left, sizeof(buf));
2746         }
2747
2748         if (ferror(fp)) {
2749                 perror("fread");
2750                 return -1;
2751         }
2752
2753         return 0;
2754 }
2755
2756 gint copy_file_part(FILE *fp, off_t offset, size_t length, const gchar *dest)
2757 {
2758         FILE *dest_fp;
2759         gboolean err = FALSE;
2760
2761         if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
2762                 FILE_OP_ERROR(dest, "fopen");
2763                 return -1;
2764         }
2765
2766         if (change_file_mode_rw(dest_fp, dest) < 0) {
2767                 FILE_OP_ERROR(dest, "chmod");
2768                 g_warning("can't change file mode\n");
2769         }
2770
2771         if (copy_file_part_to_fp(fp, offset, length, dest_fp) < 0)
2772                 err = TRUE;
2773
2774         if (!err && fclose(dest_fp) == EOF) {
2775                 FILE_OP_ERROR(dest, "fclose");
2776                 err = TRUE;
2777         }
2778
2779         if (err) {
2780                 g_warning("writing to %s failed.\n", dest);
2781                 g_unlink(dest);
2782                 return -1;
2783         }
2784
2785         return 0;
2786 }
2787
2788 /* convert line endings into CRLF. If the last line doesn't end with
2789  * linebreak, add it.
2790  */
2791 gchar *canonicalize_str(const gchar *str)
2792 {
2793         const gchar *p;
2794         guint new_len = 0;
2795         gchar *out, *outp;
2796
2797         for (p = str; *p != '\0'; ++p) {
2798                 if (*p != '\r') {
2799                         ++new_len;
2800                         if (*p == '\n')
2801                                 ++new_len;
2802                 }
2803         }
2804         if (p == str || *(p - 1) != '\n')
2805                 new_len += 2;
2806
2807         out = outp = g_malloc(new_len + 1);
2808         for (p = str; *p != '\0'; ++p) {
2809                 if (*p != '\r') {
2810                         if (*p == '\n')
2811                                 *outp++ = '\r';
2812                         *outp++ = *p;
2813                 }
2814         }
2815         if (p == str || *(p - 1) != '\n') {
2816                 *outp++ = '\r';
2817                 *outp++ = '\n';
2818         }
2819         *outp = '\0';
2820
2821         return out;
2822 }
2823
2824 gint canonicalize_file(const gchar *src, const gchar *dest)
2825 {
2826         FILE *src_fp, *dest_fp;
2827         gchar buf[BUFFSIZE];
2828         gint len;
2829         gboolean err = FALSE;
2830         gboolean last_linebreak = FALSE;
2831
2832         if ((src_fp = g_fopen(src, "rb")) == NULL) {
2833                 FILE_OP_ERROR(src, "fopen");
2834                 return -1;
2835         }
2836
2837         if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
2838                 FILE_OP_ERROR(dest, "fopen");
2839                 fclose(src_fp);
2840                 return -1;
2841         }
2842
2843         if (change_file_mode_rw(dest_fp, dest) < 0) {
2844                 FILE_OP_ERROR(dest, "chmod");
2845                 g_warning("can't change file mode\n");
2846         }
2847
2848         while (fgets(buf, sizeof(buf), src_fp) != NULL) {
2849                 gint r = 0;
2850
2851                 len = strlen(buf);
2852                 if (len == 0) break;
2853                 last_linebreak = FALSE;
2854
2855                 if (buf[len - 1] != '\n') {
2856                         last_linebreak = TRUE;
2857                         r = fputs(buf, dest_fp);
2858                 } else if (len > 1 && buf[len - 1] == '\n' && buf[len - 2] == '\r') {
2859                         r = fputs(buf, dest_fp);
2860                 } else {
2861                         if (len > 1) {
2862                                 r = fwrite(buf, 1, len - 1, dest_fp);
2863                                 if (r != (len -1))
2864                                         r = EOF;
2865                         }
2866                         if (r != EOF)
2867                                 r = fputs("\r\n", dest_fp);
2868                 }
2869
2870                 if (r == EOF) {
2871                         g_warning("writing to %s failed.\n", dest);
2872                         fclose(dest_fp);
2873                         fclose(src_fp);
2874                         g_unlink(dest);
2875                         return -1;
2876                 }
2877         }
2878
2879         if (last_linebreak == TRUE) {
2880                 if (fputs("\r\n", dest_fp) == EOF)
2881                         err = TRUE;
2882         }
2883
2884         if (ferror(src_fp)) {
2885                 FILE_OP_ERROR(src, "fgets");
2886                 err = TRUE;
2887         }
2888         fclose(src_fp);
2889         if (fclose(dest_fp) == EOF) {
2890                 FILE_OP_ERROR(dest, "fclose");
2891                 err = TRUE;
2892         }
2893
2894         if (err) {
2895                 g_unlink(dest);
2896                 return -1;
2897         }
2898
2899         return 0;
2900 }
2901
2902 gint canonicalize_file_replace(const gchar *file)
2903 {
2904         gchar *tmp_file;
2905
2906         tmp_file = get_tmp_file();
2907
2908         if (canonicalize_file(file, tmp_file) < 0) {
2909                 g_free(tmp_file);
2910                 return -1;
2911         }
2912
2913         if (move_file(tmp_file, file, TRUE) < 0) {
2914                 g_warning("can't replace %s .\n", file);
2915                 g_unlink(tmp_file);
2916                 g_free(tmp_file);
2917                 return -1;
2918         }
2919
2920         g_free(tmp_file);
2921         return 0;
2922 }
2923
2924 gint uncanonicalize_file(const gchar *src, const gchar *dest)
2925 {
2926         FILE *src_fp, *dest_fp;
2927         gchar buf[BUFFSIZE];
2928         gboolean err = FALSE;
2929
2930         if ((src_fp = g_fopen(src, "rb")) == NULL) {
2931                 FILE_OP_ERROR(src, "fopen");
2932                 return -1;
2933         }
2934
2935         if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
2936                 FILE_OP_ERROR(dest, "fopen");
2937                 fclose(src_fp);
2938                 return -1;
2939         }
2940
2941         if (change_file_mode_rw(dest_fp, dest) < 0) {
2942                 FILE_OP_ERROR(dest, "chmod");
2943                 g_warning("can't change file mode\n");
2944         }
2945
2946         while (fgets(buf, sizeof(buf), src_fp) != NULL) {
2947                 strcrchomp(buf);
2948                 if (fputs(buf, dest_fp) == EOF) {
2949                         g_warning("writing to %s failed.\n", dest);
2950                         fclose(dest_fp);
2951                         fclose(src_fp);
2952                         g_unlink(dest);
2953                         return -1;
2954                 }
2955         }
2956
2957         if (ferror(src_fp)) {
2958                 FILE_OP_ERROR(src, "fgets");
2959                 err = TRUE;
2960         }
2961         fclose(src_fp);
2962         if (fclose(dest_fp) == EOF) {
2963                 FILE_OP_ERROR(dest, "fclose");
2964                 err = TRUE;
2965         }
2966
2967         if (err) {
2968                 g_unlink(dest);
2969                 return -1;
2970         }
2971
2972         return 0;
2973 }
2974
2975 gint uncanonicalize_file_replace(const gchar *file)
2976 {
2977         gchar *tmp_file;
2978
2979         tmp_file = get_tmp_file();
2980
2981         if (uncanonicalize_file(file, tmp_file) < 0) {
2982                 g_free(tmp_file);
2983                 return -1;
2984         }
2985
2986         if (move_file(tmp_file, file, TRUE) < 0) {
2987                 g_warning("can't replace %s .\n", file);
2988                 g_unlink(tmp_file);
2989                 g_free(tmp_file);
2990                 return -1;
2991         }
2992
2993         g_free(tmp_file);
2994         return 0;
2995 }
2996
2997 gchar *normalize_newlines(const gchar *str)
2998 {
2999         const gchar *p = str;
3000         gchar *out, *outp;
3001
3002         out = outp = g_malloc(strlen(str) + 1);
3003         for (p = str; *p != '\0'; ++p) {
3004                 if (*p == '\r') {
3005                         if (*(p + 1) != '\n')
3006                                 *outp++ = '\n';
3007                 } else
3008                         *outp++ = *p;
3009         }
3010
3011         *outp = '\0';
3012
3013         return out;
3014 }
3015
3016 gchar *get_outgoing_rfc2822_str(FILE *fp)
3017 {
3018         gchar buf[BUFFSIZE];
3019         GString *str;
3020         gchar *ret;
3021
3022         str = g_string_new(NULL);
3023
3024         /* output header part */
3025         while (fgets(buf, sizeof(buf), fp) != NULL) {
3026                 strretchomp(buf);
3027                 if (!g_ascii_strncasecmp(buf, "Bcc:", 4)) {
3028                         gint next;
3029
3030                         for (;;) {
3031                                 next = fgetc(fp);
3032                                 if (next == EOF)
3033                                         break;
3034                                 else if (next != ' ' && next != '\t') {
3035                                         ungetc(next, fp);
3036                                         break;
3037                                 }
3038                                 if (fgets(buf, sizeof(buf), fp) == NULL)
3039                                         break;
3040                         }
3041                 } else {
3042                         g_string_append(str, buf);
3043                         g_string_append(str, "\r\n");
3044                         if (buf[0] == '\0')
3045                                 break;
3046                 }
3047         }
3048
3049         /* output body part */
3050         while (fgets(buf, sizeof(buf), fp) != NULL) {
3051                 strretchomp(buf);
3052                 if (buf[0] == '.')
3053                         g_string_append_c(str, '.');
3054                 g_string_append(str, buf);
3055                 g_string_append(str, "\r\n");
3056         }
3057
3058         ret = str->str;
3059         g_string_free(str, FALSE);
3060
3061         return ret;
3062 }
3063
3064 /*
3065  * Create a new boundary in a way that it is very unlikely that this
3066  * will occur in the following text.  It would be easy to ensure
3067  * uniqueness if everything is either quoted-printable or base64
3068  * encoded (note that conversion is allowed), but because MIME bodies
3069  * may be nested, it may happen that the same boundary has already
3070  * been used.
3071  *
3072  *   boundary := 0*69<bchars> bcharsnospace
3073  *   bchars := bcharsnospace / " "
3074  *   bcharsnospace := DIGIT / ALPHA / "'" / "(" / ")" /
3075  *                  "+" / "_" / "," / "-" / "." /
3076  *                  "/" / ":" / "=" / "?"
3077  *
3078  * some special characters removed because of buggy MTAs
3079  */
3080
3081 gchar *generate_mime_boundary(const gchar *prefix)
3082 {
3083         static gchar tbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
3084                              "abcdefghijklmnopqrstuvwxyz"
3085                              "1234567890+_./=";
3086         gchar buf_uniq[24];
3087         gint i;
3088
3089         for (i = 0; i < sizeof(buf_uniq) - 1; i++)
3090                 buf_uniq[i] = tbl[g_random_int_range(0, sizeof(tbl) - 1)];
3091         buf_uniq[i] = '\0';
3092
3093         return g_strdup_printf("%s_%s", prefix ? prefix : "MP",
3094                                buf_uniq);
3095 }
3096
3097 gint change_file_mode_rw(FILE *fp, const gchar *file)
3098 {
3099 #if HAVE_FCHMOD
3100         return fchmod(fileno(fp), S_IRUSR|S_IWUSR);
3101 #else
3102         return g_chmod(file, S_IRUSR|S_IWUSR);
3103 #endif
3104 }
3105
3106 FILE *my_tmpfile(void)
3107 {
3108 #if HAVE_MKSTEMP || defined(G_OS_WIN32)
3109         const gchar suffix[] = ".XXXXXX";
3110         const gchar *tmpdir;
3111         guint tmplen;
3112         const gchar *progname;
3113         guint proglen;
3114         gchar *fname;
3115         gint fd;
3116         FILE *fp;
3117         gchar buf[2]="\0";
3118
3119         tmpdir = get_tmp_dir();
3120         tmplen = strlen(tmpdir);
3121         progname = g_get_prgname();
3122         if (progname == NULL)
3123                 progname = "claws-mail";
3124         proglen = strlen(progname);
3125         Xalloca(fname, tmplen + 1 + proglen + sizeof(suffix),
3126                 return tmpfile());
3127
3128         memcpy(fname, tmpdir, tmplen);
3129         fname[tmplen] = G_DIR_SEPARATOR;
3130         memcpy(fname + tmplen + 1, progname, proglen);
3131         memcpy(fname + tmplen + 1 + proglen, suffix, sizeof(suffix));
3132
3133         fd = mkstemp(fname);
3134         if (fd < 0)
3135                 return tmpfile();
3136
3137 #ifndef G_OS_WIN32
3138         g_unlink(fname);
3139         
3140         /* verify that we can write in the file after unlinking */
3141         if (write(fd, buf, 1) < 0) {
3142                 close(fd);
3143                 return tmpfile();
3144         }
3145         
3146 #endif
3147
3148         fp = fdopen(fd, "w+b");
3149         if (!fp)
3150                 close(fd);
3151         else {
3152                 rewind(fp);
3153                 return fp;
3154         }
3155
3156 #endif /* HAVE_MKSTEMP || G_OS_WIN32 */
3157
3158         return tmpfile();
3159 }
3160
3161 FILE *get_tmpfile_in_dir(const gchar *dir, gchar **filename)
3162 {
3163         int fd;
3164 #ifdef G_OS_WIN32
3165         char *template = g_strdup_printf ("%s%csylpheed.XXXXXX",
3166                                           dir, G_DIR_SEPARATOR);
3167         fd = mkstemp_name(template, filename);
3168         g_free(template);
3169 #else
3170         *filename = g_strdup_printf("%s%csylpheed.XXXXXX", dir, G_DIR_SEPARATOR);
3171         fd = mkstemp(*filename);
3172 #endif
3173         return fdopen(fd, "w+");
3174 }
3175
3176 FILE *str_open_as_stream(const gchar *str)
3177 {
3178         FILE *fp;
3179         size_t len;
3180
3181         g_return_val_if_fail(str != NULL, NULL);
3182
3183         fp = my_tmpfile();
3184         if (!fp) {
3185                 FILE_OP_ERROR("str_open_as_stream", "my_tmpfile");
3186                 return NULL;
3187         }
3188
3189         len = strlen(str);
3190         if (len == 0) return fp;
3191
3192         if (fwrite(str, 1, len, fp) != len) {
3193                 FILE_OP_ERROR("str_open_as_stream", "fwrite");
3194                 fclose(fp);
3195                 return NULL;
3196         }
3197
3198         rewind(fp);
3199         return fp;
3200 }
3201
3202 gint str_write_to_file(const gchar *str, const gchar *file)
3203 {
3204         FILE *fp;
3205         size_t len;
3206
3207         g_return_val_if_fail(str != NULL, -1);
3208         g_return_val_if_fail(file != NULL, -1);
3209
3210         if ((fp = g_fopen(file, "wb")) == NULL) {
3211                 FILE_OP_ERROR(file, "fopen");
3212                 return -1;
3213         }
3214
3215         len = strlen(str);
3216         if (len == 0) {
3217                 fclose(fp);
3218                 return 0;
3219         }
3220
3221         if (fwrite(str, 1, len, fp) != len) {
3222                 FILE_OP_ERROR(file, "fwrite");
3223                 fclose(fp);
3224                 g_unlink(file);
3225                 return -1;
3226         }
3227
3228         if (fclose(fp) == EOF) {
3229                 FILE_OP_ERROR(file, "fclose");
3230                 g_unlink(file);
3231                 return -1;
3232         }
3233
3234         return 0;
3235 }
3236
3237 gchar *file_read_to_str(const gchar *file)
3238 {
3239         FILE *fp;
3240         gchar *str;
3241
3242         g_return_val_if_fail(file != NULL, NULL);
3243
3244         if ((fp = g_fopen(file, "rb")) == NULL) {
3245                 FILE_OP_ERROR(file, "fopen");
3246                 return NULL;
3247         }
3248
3249         str = file_read_stream_to_str(fp);
3250
3251         fclose(fp);
3252
3253         return str;
3254 }
3255
3256 gchar *file_read_stream_to_str(FILE *fp)
3257 {
3258         GByteArray *array;
3259         guchar buf[BUFSIZ];
3260         gint n_read;
3261         gchar *str;
3262
3263         g_return_val_if_fail(fp != NULL, NULL);
3264
3265         array = g_byte_array_new();
3266
3267         while ((n_read = fread(buf, sizeof(gchar), sizeof(buf), fp)) > 0) {
3268                 if (n_read < sizeof(buf) && ferror(fp))
3269                         break;
3270                 g_byte_array_append(array, buf, n_read);
3271         }
3272
3273         if (ferror(fp)) {
3274                 FILE_OP_ERROR("file stream", "fread");
3275                 g_byte_array_free(array, TRUE);
3276                 return NULL;
3277         }
3278
3279         buf[0] = '\0';
3280         g_byte_array_append(array, buf, 1);
3281         str = (gchar *)array->data;
3282         g_byte_array_free(array, FALSE);
3283
3284         if (!g_utf8_validate(str, -1, NULL)) {
3285                 const gchar *src_codeset, *dest_codeset;
3286                 gchar *tmp = NULL;
3287                 src_codeset = conv_get_locale_charset_str();
3288                 dest_codeset = CS_UTF_8;
3289                 tmp = conv_codeset_strdup(str, src_codeset, dest_codeset);
3290                 g_free(str);
3291                 str = tmp;
3292         }
3293
3294         return str;
3295 }
3296
3297 gint execute_async(gchar *const argv[])
3298 {
3299         g_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
3300
3301         if (g_spawn_async(NULL, (gchar **)argv, NULL, G_SPAWN_SEARCH_PATH,
3302                           NULL, NULL, NULL, FALSE) == FALSE) {
3303                 g_warning("Couldn't execute command: %s\n", argv[0]);
3304                 return -1;
3305         }
3306
3307         return 0;
3308 }
3309
3310 gint execute_sync(gchar *const argv[])
3311 {
3312         gint status;
3313
3314         g_return_val_if_fail(argv != NULL && argv[0] != NULL, -1);
3315
3316         if (g_spawn_sync(NULL, (gchar **)argv, NULL, G_SPAWN_SEARCH_PATH,
3317                          NULL, NULL, NULL, NULL, &status, NULL) == FALSE) {
3318                 g_warning("Couldn't execute command: %s\n", argv[0]);
3319                 return -1;
3320         }
3321
3322 #ifdef G_OS_UNIX
3323         if (WIFEXITED(status))
3324                 return WEXITSTATUS(status);
3325         else
3326                 return -1;
3327 #else
3328         return status;
3329 #endif
3330 }
3331
3332 gint execute_command_line(const gchar *cmdline, gboolean async)
3333 {
3334         gchar **argv;
3335         gint ret;
3336
3337         debug_print("execute_command_line(): executing: %s\n", cmdline);
3338
3339         argv = strsplit_with_quote(cmdline, " ", 0);
3340
3341         if (async)
3342                 ret = execute_async(argv);
3343         else
3344                 ret = execute_sync(argv);
3345
3346         g_strfreev(argv);
3347
3348         return ret;
3349 }
3350
3351 gchar *get_command_output(const gchar *cmdline)
3352 {
3353         gchar *child_stdout;
3354         gint status;
3355
3356         g_return_val_if_fail(cmdline != NULL, NULL);
3357
3358         debug_print("get_command_output(): executing: %s\n", cmdline);
3359
3360         if (g_spawn_command_line_sync(cmdline, &child_stdout, NULL, &status,
3361                                       NULL) == FALSE) {
3362                 g_warning("Couldn't execute command: %s\n", cmdline);
3363                 return NULL;
3364         }
3365
3366         return child_stdout;
3367 }
3368
3369 static gint is_unchanged_uri_char(char c)
3370 {
3371         switch (c) {
3372                 case '(':
3373                 case ')':
3374                 case ',':
3375                         return 0;
3376                 default:
3377                         return 1;
3378         }
3379 }
3380
3381 void encode_uri(gchar *encoded_uri, gint bufsize, const gchar *uri)
3382 {
3383         int i;
3384         int k;
3385
3386         k = 0;
3387         for(i = 0; i < strlen(uri) ; i++) {
3388                 if (is_unchanged_uri_char(uri[i])) {
3389                         if (k + 2 >= bufsize)
3390                                 break;
3391                         encoded_uri[k++] = uri[i];
3392                 }
3393                 else {
3394                         char * hexa = "0123456789ABCDEF";
3395
3396                         if (k + 4 >= bufsize)
3397                                 break;
3398                         encoded_uri[k++] = '%';
3399                         encoded_uri[k++] = hexa[uri[i] / 16];
3400                         encoded_uri[k++] = hexa[uri[i] % 16];
3401                 }
3402         }
3403         encoded_uri[k] = 0;
3404 }
3405
3406 gint open_uri(const gchar *uri, const gchar *cmdline)
3407 {
3408         gchar buf[BUFFSIZE];
3409         gchar *p;
3410         gchar encoded_uri[BUFFSIZE];
3411
3412         g_return_val_if_fail(uri != NULL, -1);
3413
3414         /* an option to choose whether to use encode_uri or not ? */
3415         encode_uri(encoded_uri, BUFFSIZE, uri);
3416
3417         if (cmdline &&
3418             (p = strchr(cmdline, '%')) && *(p + 1) == 's' &&
3419             !strchr(p + 2, '%'))
3420                 g_snprintf(buf, sizeof(buf), cmdline, encoded_uri);
3421         else {
3422                 if (cmdline)
3423                         g_warning("Open URI command line is invalid "
3424                                   "(there must be only one '%%s'): %s",
3425                                   cmdline);
3426                 g_snprintf(buf, sizeof(buf), DEFAULT_BROWSER_CMD, encoded_uri);
3427         }
3428
3429         execute_command_line(buf, TRUE);
3430
3431         return 0;
3432 }
3433
3434 gint open_txt_editor(const gchar *filepath, const gchar *cmdline)
3435 {
3436         gchar buf[BUFFSIZE];
3437         gchar *p;
3438
3439         g_return_val_if_fail(filepath != NULL, -1);
3440
3441         if (cmdline &&
3442             (p = strchr(cmdline, '%')) && *(p + 1) == 's' &&
3443             !strchr(p + 2, '%'))
3444                 g_snprintf(buf, sizeof(buf), cmdline, filepath);
3445         else {
3446                 if (cmdline)
3447                         g_warning("Open Text Editor command line is invalid "
3448                                   "(there must be only one '%%s'): %s",
3449                                   cmdline);
3450                 g_snprintf(buf, sizeof(buf), DEFAULT_EDITOR_CMD, filepath);
3451         }
3452
3453         execute_command_line(buf, TRUE);
3454
3455         return 0;
3456 }
3457
3458 time_t remote_tzoffset_sec(const gchar *zone)
3459 {
3460         static gchar ustzstr[] = "PSTPDTMSTMDTCSTCDTESTEDT";
3461         gchar zone3[4];
3462         gchar *p;
3463         gchar c;
3464         gint iustz;
3465         gint offset;
3466         time_t remoteoffset;
3467
3468         strncpy(zone3, zone, 3);
3469         zone3[3] = '\0';
3470         remoteoffset = 0;
3471
3472         if (sscanf(zone, "%c%d", &c, &offset) == 2 &&
3473             (c == '+' || c == '-')) {
3474                 remoteoffset = ((offset / 100) * 60 + (offset % 100)) * 60;
3475                 if (c == '-')
3476                         remoteoffset = -remoteoffset;
3477         } else if (!strncmp(zone, "UT" , 2) ||
3478                    !strncmp(zone, "GMT", 2)) {
3479                 remoteoffset = 0;
3480         } else if (strlen(zone3) == 3) {
3481                 for (p = ustzstr; *p != '\0'; p += 3) {
3482                         if (!g_ascii_strncasecmp(p, zone3, 3)) {
3483                                 iustz = ((gint)(p - ustzstr) / 3 + 1) / 2 - 8;
3484                                 remoteoffset = iustz * 3600;
3485                                 break;
3486                         }
3487                 }
3488                 if (*p == '\0')
3489                         return -1;
3490         } else if (strlen(zone3) == 1) {
3491                 switch (zone[0]) {
3492                 case 'Z': remoteoffset =   0; break;
3493                 case 'A': remoteoffset =  -1; break;
3494                 case 'B': remoteoffset =  -2; break;
3495                 case 'C': remoteoffset =  -3; break;
3496                 case 'D': remoteoffset =  -4; break;
3497                 case 'E': remoteoffset =  -5; break;
3498                 case 'F': remoteoffset =  -6; break;
3499                 case 'G': remoteoffset =  -7; break;
3500                 case 'H': remoteoffset =  -8; break;
3501                 case 'I': remoteoffset =  -9; break;
3502                 case 'K': remoteoffset = -10; break; /* J is not used */
3503                 case 'L': remoteoffset = -11; break;
3504                 case 'M': remoteoffset = -12; break;
3505                 case 'N': remoteoffset =   1; break;
3506                 case 'O': remoteoffset =   2; break;
3507                 case 'P': remoteoffset =   3; break;
3508                 case 'Q': remoteoffset =   4; break;
3509                 case 'R': remoteoffset =   5; break;
3510                 case 'S': remoteoffset =   6; break;
3511                 case 'T': remoteoffset =   7; break;
3512                 case 'U': remoteoffset =   8; break;
3513                 case 'V': remoteoffset =   9; break;
3514                 case 'W': remoteoffset =  10; break;
3515                 case 'X': remoteoffset =  11; break;
3516                 case 'Y': remoteoffset =  12; break;
3517                 default:  remoteoffset =   0; break;
3518                 }
3519                 remoteoffset = remoteoffset * 3600;
3520         } else
3521                 return -1;
3522
3523         return remoteoffset;
3524 }
3525
3526 time_t tzoffset_sec(time_t *now)
3527 {
3528         struct tm gmt, *lt;
3529         gint off;
3530
3531         gmt = *gmtime(now);
3532         lt = localtime(now);
3533
3534         off = (lt->tm_hour - gmt.tm_hour) * 60 + lt->tm_min - gmt.tm_min;
3535
3536         if (lt->tm_year < gmt.tm_year)
3537                 off -= 24 * 60;
3538         else if (lt->tm_year > gmt.tm_year)
3539                 off += 24 * 60;
3540         else if (lt->tm_yday < gmt.tm_yday)
3541                 off -= 24 * 60;
3542         else if (lt->tm_yday > gmt.tm_yday)
3543                 off += 24 * 60;
3544
3545         if (off >= 24 * 60)             /* should be impossible */
3546                 off = 23 * 60 + 59;     /* if not, insert silly value */
3547         if (off <= -24 * 60)
3548                 off = -(23 * 60 + 59);
3549
3550         return off * 60;
3551 }
3552
3553 /* calculate timezone offset */
3554 gchar *tzoffset(time_t *now)
3555 {
3556         static gchar offset_string[6];
3557         struct tm gmt, *lt;
3558         gint off;
3559         gchar sign = '+';
3560
3561         gmt = *gmtime(now);
3562         lt = localtime(now);
3563
3564         off = (lt->tm_hour - gmt.tm_hour) * 60 + lt->tm_min - gmt.tm_min;
3565
3566         if (lt->tm_year < gmt.tm_year)
3567                 off -= 24 * 60;
3568         else if (lt->tm_year > gmt.tm_year)
3569                 off += 24 * 60;
3570         else if (lt->tm_yday < gmt.tm_yday)
3571                 off -= 24 * 60;
3572         else if (lt->tm_yday > gmt.tm_yday)
3573                 off += 24 * 60;
3574
3575         if (off < 0) {
3576                 sign = '-';
3577                 off = -off;
3578         }
3579
3580         if (off >= 24 * 60)             /* should be impossible */
3581                 off = 23 * 60 + 59;     /* if not, insert silly value */
3582
3583         sprintf(offset_string, "%c%02d%02d", sign, off / 60, off % 60);
3584
3585         return offset_string;
3586 }
3587
3588 void get_rfc822_date(gchar *buf, gint len)
3589 {
3590         struct tm *lt;
3591         time_t t;
3592         gchar day[4], mon[4];
3593         gint dd, hh, mm, ss, yyyy;
3594
3595         t = time(NULL);
3596         lt = localtime(&t);
3597
3598         sscanf(asctime(lt), "%3s %3s %d %d:%d:%d %d\n",
3599                day, mon, &dd, &hh, &mm, &ss, &yyyy);
3600         g_snprintf(buf, len, "%s, %d %s %d %02d:%02d:%02d %s",
3601                    day, dd, mon, yyyy, hh, mm, ss, tzoffset(&t));
3602 }
3603
3604 /* just a wrapper to suppress the warning of gcc about %c */
3605 size_t my_strftime(gchar *s, size_t max, const gchar *format,
3606                    const struct tm *tm)
3607 {
3608         return strftime(s, max, format, tm);
3609 }
3610
3611 void debug_set_mode(gboolean mode)
3612 {
3613         debug_mode = mode;
3614 }
3615
3616 gboolean debug_get_mode(void)
3617 {
3618         return debug_mode;
3619 }
3620
3621 void debug_print_real(const gchar *format, ...)
3622 {
3623         va_list args;
3624         gchar buf[BUFFSIZE];
3625
3626         if (!debug_mode) return;
3627
3628         va_start(args, format);
3629         g_vsnprintf(buf, sizeof(buf), format, args);
3630         va_end(args);
3631
3632         g_print("%s", buf);
3633 }
3634
3635
3636 const char * debug_srcname(const char *file)
3637 {
3638         const char *s = strrchr (file, '/');
3639         return s? s+1:file;
3640 }
3641
3642
3643 void * subject_table_lookup(GHashTable *subject_table, gchar * subject)
3644 {
3645         if (subject == NULL)
3646                 subject = "";
3647         else
3648                 subject += subject_get_prefix_length(subject);
3649
3650         return g_hash_table_lookup(subject_table, subject);
3651 }
3652
3653 void subject_table_insert(GHashTable *subject_table, gchar * subject,
3654                           void * data)
3655 {
3656         if (subject == NULL || *subject == 0)
3657                 return;
3658         subject += subject_get_prefix_length(subject);
3659         g_hash_table_insert(subject_table, subject, data);
3660 }
3661
3662 void subject_table_remove(GHashTable *subject_table, gchar * subject)
3663 {
3664         if (subject == NULL)
3665                 return;
3666
3667         subject += subject_get_prefix_length(subject);
3668         g_hash_table_remove(subject_table, subject);
3669 }
3670
3671 /*!
3672  *\brief        Check if a string is prefixed with known (combinations)
3673  *              of prefixes. The function assumes that each prefix
3674  *              is terminated by zero or exactly _one_ space.
3675  *
3676  *\param        str String to check for a prefixes
3677  *
3678  *\return       int Number of chars in the prefix that should be skipped
3679  *              for a "clean" subject line. If no prefix was found, 0
3680  *              is returned.
3681  */
3682 int subject_get_prefix_length(const gchar *subject)
3683 {
3684         /*!< Array with allowable reply prefixes regexps. */
3685         static const gchar * const prefixes[] = {
3686                 "Re\\:",                        /* "Re:" */
3687                 "Re\\[[1-9][0-9]*\\]\\:",       /* "Re[XXX]:" (non-conforming news mail clients) */
3688                 "Antw\\:",                      /* "Antw:" (Dutch / German Outlook) */
3689                 "Aw\\:",                        /* "Aw:"   (German) */
3690                 "Antwort\\:",                   /* "Antwort:" (German Lotus Notes) */
3691                 "Res\\:",                       /* "Res:" (Brazilian Outlook) */
3692                 "Fw\\:",                        /* "Fw:" Forward */
3693                 "Enc\\:",                       /* "Enc:" Forward (Brazilian Outlook) */
3694                 "Odp\\:",                       /* "Odp:" Re (Polish Outlook) */
3695                 "Rif\\:",                       /* "Rif:" (Italian Outlook) */
3696                 "Sv\\:",                        /* "Sv" (Norwegian) */
3697                 "Vs\\:",                        /* "Vs" (Norwegian) */
3698                 "Ad\\:",                        /* "Ad" (Norwegian) */
3699                 "\347\255\224\345\244\215\\:"   /* "Re" (Chinese, UTF-8) */
3700                 /* add more */
3701         };
3702         const int PREFIXES = sizeof prefixes / sizeof prefixes[0];
3703         int n;
3704         regmatch_t pos;
3705         static regex_t regex;
3706         static gboolean init_;
3707
3708         if (!subject) return 0;
3709         if (!*subject) return 0;
3710
3711         if (!init_) {
3712                 GString *s = g_string_new("");
3713
3714                 for (n = 0; n < PREFIXES; n++)
3715                         /* Terminate each prefix regexpression by a
3716                          * "\ ?" (zero or ONE space), and OR them */
3717                         g_string_append_printf(s, "(%s\\ ?)%s",
3718                                           prefixes[n],
3719                                           n < PREFIXES - 1 ?
3720                                           "|" : "");
3721
3722                 g_string_prepend(s, "(");
3723                 g_string_append(s, ")+");       /* match at least once */
3724                 g_string_prepend(s, "^\\ *");   /* from beginning of line */
3725
3726
3727                 /* We now have something like "^\ *((PREFIX1\ ?)|(PREFIX2\ ?))+"
3728                  * TODO: Should this be       "^\ *(((PREFIX1)|(PREFIX2))\ ?)+" ??? */
3729                 if (regcomp(&regex, s->str, REG_EXTENDED | REG_ICASE)) {
3730                         debug_print("Error compiling regexp %s\n", s->str);
3731                         g_string_free(s, TRUE);
3732                         return 0;
3733                 } else {
3734                         init_ = TRUE;
3735                         g_string_free(s, TRUE);
3736                 }
3737         }
3738
3739         if (!regexec(&regex, subject, 1, &pos, 0) && pos.rm_so != -1)
3740                 return pos.rm_eo;
3741         else
3742                 return 0;
3743 }
3744
3745 guint g_stricase_hash(gconstpointer gptr)
3746 {
3747         guint hash_result = 0;
3748         const char *str;
3749
3750         for (str = gptr; str && *str; str++) {
3751                 hash_result += toupper(*str);
3752         }
3753
3754         return hash_result;
3755 }
3756
3757 gint g_stricase_equal(gconstpointer gptr1, gconstpointer gptr2)
3758 {
3759         const char *str1 = gptr1;
3760         const char *str2 = gptr2;
3761
3762         return !strcasecmp(str1, str2);
3763 }
3764
3765 gint g_int_compare(gconstpointer a, gconstpointer b)
3766 {
3767         return GPOINTER_TO_INT(a) - GPOINTER_TO_INT(b);
3768 }
3769
3770 gchar *generate_msgid(gchar *buf, gint len)
3771 {
3772         struct tm *lt;
3773         time_t t;
3774         gchar *addr;
3775
3776         t = time(NULL);
3777         lt = localtime(&t);
3778
3779         addr = g_strconcat("@", get_domain_name(), NULL);
3780
3781         g_snprintf(buf, len, "%04d%02d%02d%02d%02d%02d.%08x%s",
3782                    lt->tm_year + 1900, lt->tm_mon + 1,
3783                    lt->tm_mday, lt->tm_hour,
3784                    lt->tm_min, lt->tm_sec,
3785                    (guint) rand(), addr);
3786
3787         g_free(addr);
3788         return buf;
3789 }
3790
3791 /*
3792    quote_cmd_argument()
3793
3794    return a quoted string safely usable in argument of a command.
3795
3796    code is extracted and adapted from etPan! project -- DINH V. HoĆ .
3797 */
3798
3799 gint quote_cmd_argument(gchar * result, guint size,
3800                         const gchar * path)
3801 {
3802         const gchar * p;
3803         gchar * result_p;
3804         guint remaining;
3805
3806         result_p = result;
3807         remaining = size;
3808
3809         for(p = path ; * p != '\0' ; p ++) {
3810
3811                 if (isalnum((guchar)*p) || (* p == '/')) {
3812                         if (remaining > 0) {
3813                                 * result_p = * p;
3814                                 result_p ++;
3815                                 remaining --;
3816                         }
3817                         else {
3818                                 result[size - 1] = '\0';
3819                                 return -1;
3820                         }
3821                 }
3822                 else {
3823                         if (remaining >= 2) {
3824                                 * result_p = '\\';
3825                                 result_p ++;
3826                                 * result_p = * p;
3827                                 result_p ++;
3828                                 remaining -= 2;
3829                         }
3830                         else {
3831                                 result[size - 1] = '\0';
3832                                 return -1;
3833                         }
3834                 }
3835         }
3836         if (remaining > 0) {
3837                 * result_p = '\0';
3838         }
3839         else {
3840                 result[size - 1] = '\0';
3841                 return -1;
3842         }
3843
3844         return 0;
3845 }
3846
3847 typedef struct
3848 {
3849         GNode           *parent;
3850         GNodeMapFunc     func;
3851         gpointer         data;
3852 } GNodeMapData;
3853
3854 static void g_node_map_recursive(GNode *node, gpointer data)
3855 {
3856         GNodeMapData *mapdata = (GNodeMapData *) data;
3857         GNode *newnode;
3858         GNodeMapData newmapdata;
3859         gpointer newdata;
3860
3861         newdata = mapdata->func(node->data, mapdata->data);
3862         if (newdata != NULL) {
3863                 newnode = g_node_new(newdata);
3864                 g_node_append(mapdata->parent, newnode);
3865
3866                 newmapdata.parent = newnode;
3867                 newmapdata.func = mapdata->func;
3868                 newmapdata.data = mapdata->data;
3869
3870                 g_node_children_foreach(node, G_TRAVERSE_ALL, g_node_map_recursive, &newmapdata);
3871         }
3872 }
3873
3874 GNode *g_node_map(GNode *node, GNodeMapFunc func, gpointer data)
3875 {
3876         GNode *root;
3877         GNodeMapData mapdata;
3878
3879         g_return_val_if_fail(node != NULL, NULL);
3880         g_return_val_if_fail(func != NULL, NULL);
3881
3882         root = g_node_new(func(node->data, data));
3883
3884         mapdata.parent = root;
3885         mapdata.func = func;
3886         mapdata.data = data;
3887
3888         g_node_children_foreach(node, G_TRAVERSE_ALL, g_node_map_recursive, &mapdata);
3889
3890         return root;
3891 }
3892
3893 #define HEX_TO_INT(val, hex)                    \
3894 {                                               \
3895         gchar c = hex;                          \
3896                                                 \
3897         if ('0' <= c && c <= '9') {             \
3898                 val = c - '0';                  \
3899         } else if ('a' <= c && c <= 'f') {      \
3900                 val = c - 'a' + 10;             \
3901         } else if ('A' <= c && c <= 'F') {      \
3902                 val = c - 'A' + 10;             \
3903         } else {                                \
3904                 val = -1;                       \
3905         }                                       \
3906 }
3907
3908 gboolean get_hex_value(guchar *out, gchar c1, gchar c2)
3909 {
3910         gint hi, lo;
3911
3912         HEX_TO_INT(hi, c1);
3913         HEX_TO_INT(lo, c2);
3914
3915         if (hi == -1 || lo == -1)
3916                 return FALSE;
3917
3918         *out = (hi << 4) + lo;
3919         return TRUE;
3920 }
3921
3922 #define INT_TO_HEX(hex, val)            \
3923 {                                       \
3924         if ((val) < 10)                 \
3925                 hex = '0' + (val);      \
3926         else                            \
3927                 hex = 'A' + (val) - 10; \
3928 }
3929
3930 void get_hex_str(gchar *out, guchar ch)
3931 {
3932         gchar hex;
3933
3934         INT_TO_HEX(hex, ch >> 4);
3935         *out++ = hex;
3936         INT_TO_HEX(hex, ch & 0x0f);
3937         *out++ = hex;
3938 }
3939
3940 #undef REF_DEBUG
3941 #ifndef REF_DEBUG
3942 #define G_PRINT_REF 1 == 1 ? (void) 0 : (void)
3943 #else
3944 #define G_PRINT_REF g_print
3945 #endif
3946
3947 /*!
3948  *\brief        Register ref counted pointer. It is based on GBoxed, so should
3949  *              work with anything that uses the GType system. The semantics
3950  *              are similar to a C++ auto pointer, with the exception that
3951  *              C doesn't have automatic closure (calling destructors) when
3952  *              exiting a block scope.
3953  *              Use the \ref G_TYPE_AUTO_POINTER macro instead of calling this
3954  *              function directly.
3955  *
3956  *\return       GType A GType type.
3957  */
3958 GType g_auto_pointer_register(void)
3959 {
3960         static GType auto_pointer_type;
3961         if (!auto_pointer_type)
3962                 auto_pointer_type =
3963                         g_boxed_type_register_static
3964                                 ("G_TYPE_AUTO_POINTER",
3965                                  (GBoxedCopyFunc) g_auto_pointer_copy,
3966                                  (GBoxedFreeFunc) g_auto_pointer_free);
3967         return auto_pointer_type;
3968 }
3969
3970 /*!
3971  *\brief        Structure with g_new() allocated pointer guarded by the
3972  *              auto pointer
3973  */
3974 typedef struct AutoPointerRef {
3975         void          (*free) (gpointer);
3976         gpointer        pointer;
3977         glong           cnt;
3978 } AutoPointerRef;
3979
3980 /*!
3981  *\brief        The auto pointer opaque structure that references the
3982  *              pointer guard block.
3983  */
3984 typedef struct AutoPointer {
3985         AutoPointerRef *ref;
3986         gpointer        ptr; /*!< access to protected pointer */
3987 } AutoPointer;
3988
3989 /*!
3990  *\brief        Creates an auto pointer for a g_new()ed pointer. Example:
3991  *
3992  *\code
3993  *
3994  *              ... tell gtk_list_store it should use a G_TYPE_AUTO_POINTER
3995  *              ... when assigning, copying and freeing storage elements
3996  *
3997  *              gtk_list_store_new(N_S_COLUMNS,
3998  *                                 G_TYPE_AUTO_POINTER,
3999  *                                 -1);
4000  *
4001  *
4002  *              Template *precious_data = g_new0(Template, 1);
4003  *              g_pointer protect = g_auto_pointer_new(precious_data);
4004  *
4005  *              gtk_list_store_set(container, &iter,
4006  *                                 S_DATA, protect,
4007  *                                 -1);
4008  *
4009  *              ... the gtk_list_store has copied the pointer and
4010  *              ... incremented its reference count, we should free
4011  *              ... the auto pointer (in C++ a destructor would do
4012  *              ... this for us when leaving block scope)
4013  *
4014  *              g_auto_pointer_free(protect);
4015  *
4016  *              ... gtk_list_store_set() now manages the data. When
4017  *              ... *explicitly* requesting a pointer from the list
4018  *              ... store, don't forget you get a copy that should be
4019  *              ... freed with g_auto_pointer_free() eventually.
4020  *
4021  *\endcode
4022  *
4023  *\param        pointer Pointer to be guarded.
4024  *
4025  *\return       GAuto * Pointer that should be used in containers with
4026  *              GType support.
4027  */
4028 GAuto *g_auto_pointer_new(gpointer p)
4029 {
4030         AutoPointerRef *ref;
4031         AutoPointer    *ptr;
4032
4033         if (p == NULL)
4034                 return NULL;
4035
4036         ref = g_new0(AutoPointerRef, 1);
4037         ptr = g_new0(AutoPointer, 1);
4038
4039         ref->pointer = p;
4040         ref->free = g_free;
4041         ref->cnt = 1;
4042
4043         ptr->ref = ref;
4044         ptr->ptr = p;
4045
4046 #ifdef REF_DEBUG
4047         G_PRINT_REF ("XXXX ALLOC(%lx)\n", p);
4048 #endif
4049         return ptr;
4050 }
4051
4052 /*!
4053  *\brief        Allocate an autopointer using the passed \a free function to
4054  *              free the guarded pointer
4055  */
4056 GAuto *g_auto_pointer_new_with_free(gpointer p, GFreeFunc free_)
4057 {
4058         AutoPointer *aptr;
4059
4060         if (p == NULL)
4061                 return NULL;
4062
4063         aptr = g_auto_pointer_new(p);
4064         aptr->ref->free = free_;
4065         return aptr;
4066 }
4067
4068 gpointer g_auto_pointer_get_ptr(GAuto *auto_ptr)
4069 {
4070         if (auto_ptr == NULL)
4071                 return NULL;
4072         return ((AutoPointer *) auto_ptr)->ptr;
4073 }
4074
4075 /*!
4076  *\brief        Copies an auto pointer by. It's mostly not necessary
4077  *              to call this function directly, unless you copy/assign
4078  *              the guarded pointer.
4079  *
4080  *\param        auto_ptr Auto pointer returned by previous call to
4081  *              g_auto_pointer_new_XXX()
4082  *
4083  *\return       gpointer An auto pointer
4084  */
4085 GAuto *g_auto_pointer_copy(GAuto *auto_ptr)
4086 {
4087         AutoPointer     *ptr;
4088         AutoPointerRef  *ref;
4089         AutoPointer     *newp;
4090
4091         if (auto_ptr == NULL)
4092                 return NULL;
4093
4094         ptr = auto_ptr;
4095         ref = ptr->ref;
4096         newp = g_new0(AutoPointer, 1);
4097
4098         newp->ref = ref;
4099         newp->ptr = ref->pointer;
4100         ++(ref->cnt);
4101
4102 #ifdef REF_DEBUG
4103         G_PRINT_REF ("XXXX COPY(%lx) -- REF (%d)\n", ref->pointer, ref->cnt);
4104 #endif
4105         return newp;
4106 }
4107
4108 /*!
4109  *\brief        Free an auto pointer
4110  */
4111 void g_auto_pointer_free(GAuto *auto_ptr)
4112 {
4113         AutoPointer     *ptr;
4114         AutoPointerRef  *ref;
4115
4116         if (auto_ptr == NULL)
4117                 return;
4118
4119         ptr = auto_ptr;
4120         ref = ptr->ref;
4121
4122         if (--(ref->cnt) == 0) {
4123 #ifdef REF_DEBUG
4124                 G_PRINT_REF ("XXXX FREE(%lx) -- REF (%d)\n", ref->pointer, ref->cnt);
4125 #endif
4126                 ref->free(ref->pointer);
4127                 g_free(ref);
4128         }
4129 #ifdef REF_DEBUG
4130         else
4131                 G_PRINT_REF ("XXXX DEREF(%lx) -- REF (%d)\n", ref->pointer, ref->cnt);
4132 #endif
4133         g_free(ptr);
4134 }
4135
4136 void replace_returns(gchar *str)
4137 {
4138         if (!str)
4139                 return;
4140
4141         while (strstr(str, "\n")) {
4142                 *strstr(str, "\n") = ' ';
4143         }
4144         while (strstr(str, "\r")) {
4145                 *strstr(str, "\r") = ' ';
4146         }
4147 }
4148
4149 /* get_uri_part() - retrieves a URI starting from scanpos.
4150                     Returns TRUE if succesful */
4151 gboolean get_uri_part(const gchar *start, const gchar *scanpos,
4152                              const gchar **bp, const gchar **ep, gboolean hdr)
4153 {
4154         const gchar *ep_;
4155         gint parenthese_cnt = 0;
4156
4157         g_return_val_if_fail(start != NULL, FALSE);
4158         g_return_val_if_fail(scanpos != NULL, FALSE);
4159         g_return_val_if_fail(bp != NULL, FALSE);
4160         g_return_val_if_fail(ep != NULL, FALSE);
4161
4162         *bp = scanpos;
4163
4164         /* find end point of URI */
4165         for (ep_ = scanpos; *ep_ != '\0'; ep_++) {
4166                 if (!g_ascii_isgraph(*(const guchar *)ep_) ||
4167                     !IS_ASCII(*(const guchar *)ep_) ||
4168                     strchr("[]{}<>\"", *ep_)) {
4169                         break;
4170                 } else if (strchr("(", *ep_)) {
4171                         parenthese_cnt++;
4172                 } else if (strchr(")", *ep_)) {
4173                         if (parenthese_cnt > 0)
4174                                 parenthese_cnt--;
4175                         else
4176                                 break;
4177                 }
4178         }
4179
4180         /* no punctuation at end of string */
4181
4182         /* FIXME: this stripping of trailing punctuations may bite with other URIs.
4183          * should pass some URI type to this function and decide on that whether
4184          * to perform punctuation stripping */
4185
4186 #define IS_REAL_PUNCT(ch)       (g_ascii_ispunct(ch) && !strchr("/?=-)", ch))
4187
4188         for (; ep_ - 1 > scanpos + 1 &&
4189                IS_REAL_PUNCT(*(ep_ - 1));
4190              ep_--)
4191                 ;
4192
4193 #undef IS_REAL_PUNCT
4194
4195         *ep = ep_;
4196
4197         return TRUE;
4198 }
4199
4200 gchar *make_uri_string(const gchar *bp, const gchar *ep)
4201 {
4202         while (bp && *bp && g_ascii_isspace(*bp))
4203                 bp++;
4204         return g_strndup(bp, ep - bp);
4205 }
4206
4207 /* valid mail address characters */
4208 #define IS_RFC822_CHAR(ch) \
4209         (IS_ASCII(ch) && \
4210          (ch) > 32   && \
4211          (ch) != 127 && \
4212          !g_ascii_isspace(ch) && \
4213          !strchr("(),;<>\"", (ch)))
4214
4215 /* alphabet and number within 7bit ASCII */
4216 #define IS_ASCII_ALNUM(ch)      (IS_ASCII(ch) && g_ascii_isalnum(ch))
4217 #define IS_QUOTE(ch) ((ch) == '\'' || (ch) == '"')
4218
4219 static GHashTable *create_domain_tab(void)
4220 {
4221         static const gchar *toplvl_domains [] = {
4222             "museum", "aero",
4223             "arpa", "coop", "info", "name", "biz", "com", "edu", "gov",
4224             "int", "mil", "net", "org", "ac", "ad", "ae", "af", "ag",
4225             "ai", "al", "am", "an", "ao", "aq", "ar", "as", "at", "au",
4226             "aw", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi",
4227             "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by",
4228             "bz", "ca", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl",
4229             "cm", "cn", "co", "cr", "cu", "cv", "cx", "cy", "cz", "de",
4230             "dj", "dk", "dm", "do", "dz", "ec", "ee", "eg", "eh", "er",
4231             "es", "et", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gd",
4232             "ge", "gf", "gg", "gh", "gi", "gl", "gm", "gn", "gp", "gq",
4233             "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr",
4234             "ht", "hu", "id", "ie", "il", "im", "in", "io", "iq", "ir",
4235             "is", "it", "je", "jm", "jo", "jp", "ke", "kg", "kh", "ki",
4236             "km", "kn", "kp", "kr", "kw", "ky", "kz", "la", "lb", "lc",
4237             "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma", "mc",
4238             "md", "mg", "mh", "mk", "ml", "mm", "mn", "mo", "mp", "mq",
4239             "mr", "ms", "mt", "mu", "mv", "mw", "mx", "my", "mz", "na",
4240             "nc", "ne", "nf", "ng", "ni", "nl", "no", "np", "nr", "nu",
4241             "nz", "om", "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm",
4242             "pn", "pr", "ps", "pt", "pw", "py", "qa", "re", "ro", "ru",
4243             "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si", "sj",
4244             "sk", "sl", "sm", "sn", "so", "sr", "st", "sv", "sy", "sz",
4245             "tc", "td", "tf", "tg", "th", "tj", "tk", "tm", "tn", "to",
4246             "tp", "tr", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "um",
4247             "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu",
4248             "wf", "ws", "ye", "yt", "yu", "za", "zm", "zw"
4249         };
4250         gint n;
4251         GHashTable *htab = g_hash_table_new(g_stricase_hash, g_stricase_equal);
4252
4253         g_return_val_if_fail(htab, NULL);
4254         for (n = 0; n < sizeof toplvl_domains / sizeof toplvl_domains[0]; n++)
4255                 g_hash_table_insert(htab, (gpointer) toplvl_domains[n], (gpointer) toplvl_domains[n]);
4256         return htab;
4257 }
4258
4259 static gboolean is_toplvl_domain(GHashTable *tab, const gchar *first, const gchar *last)
4260 {
4261         const gint MAX_LVL_DOM_NAME_LEN = 6;
4262         gchar buf[MAX_LVL_DOM_NAME_LEN + 1];