undo patch feature, can be enabled through compose.h by adding a #define USE_UNDO_PATCH
[claws.git] / src / compose.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 #include <gdk/gdkkeysyms.h>
28 #include <gtk/gtkmain.h>
29 #include <gtk/gtkmenu.h>
30 #include <gtk/gtkmenuitem.h>
31 #include <gtk/gtkitemfactory.h>
32 #include <gtk/gtkcheckmenuitem.h>
33 #include <gtk/gtkoptionmenu.h>
34 #include <gtk/gtkwidget.h>
35 #include <gtk/gtkclist.h>
36 #include <gtk/gtkctree.h>
37 #include <gtk/gtkvpaned.h>
38 #include <gtk/gtkentry.h>
39 #include <gtk/gtkeditable.h>
40 #include <gtk/gtkwindow.h>
41 #include <gtk/gtksignal.h>
42 #include <gtk/gtkvbox.h>
43 #include <gtk/gtkcontainer.h>
44 #include <gtk/gtkhandlebox.h>
45 #include <gtk/gtktoolbar.h>
46 #include <gtk/gtktable.h>
47 #include <gtk/gtkhbox.h>
48 #include <gtk/gtklabel.h>
49 #include <gtk/gtkscrolledwindow.h>
50 #include <gtk/gtkthemes.h>
51 #include <gtk/gtkdnd.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <ctype.h>
56 #include <unistd.h>
57 #include <time.h>
58 /* #include <sys/utsname.h> */
59 #include <stdlib.h>
60 #include <sys/wait.h>
61 #include <signal.h>
62 #include <errno.h>
63
64 #if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
65 #  include <wchar.h>
66 #  include <wctype.h>
67 #endif
68
69
70 #include "gtkstext.h"
71
72 #include "intl.h"
73 #include "main.h"
74 #include "mainwindow.h"
75 #include "compose.h"
76 #include "addressbook.h"
77 #include "folderview.h"
78 #include "procmsg.h"
79 #include "menu.h"
80 #include "send.h"
81 #include "news.h"
82 #include "customheader.h"
83 #include "prefs_common.h"
84 #include "prefs_account.h"
85 #include "account.h"
86 #include "filesel.h"
87 #include "procheader.h"
88 #include "procmime.h"
89 #include "statusbar.h"
90 #include "about.h"
91 #include "base64.h"
92 #include "codeconv.h"
93 #include "utils.h"
94 #include "gtkutils.h"
95 #include "socket.h"
96 #include "alertpanel.h"
97 #include "manage_window.h"
98 #include "gtkshruler.h"
99 #include "folder.h"
100 #include "addr_compl.h"
101 #include "template_select.h"
102 #include "quote_fmt.h"
103 #include "template.h"
104
105 /* DINH V. Hoa - waiting for definitive version
106    of undo patch */
107 #ifdef USE_UNDO_PATCH
108 #include "undo.h"
109 #endif
110
111 #if USE_GPGME
112 #  include "rfc2015.h"
113 #endif
114
115 typedef enum
116 {
117         COL_MIMETYPE = 0,
118         COL_SIZE     = 1,
119         COL_NAME     = 2
120 } AttachColumnPos;
121
122 #define N_ATTACH_COLS           3
123
124 #define B64_LINE_SIZE           57
125 #define B64_BUFFSIZE            77
126
127 #define MAX_REFERENCES_LEN      999
128
129 static GdkColor quote_color = {0, 0, 0, 0xbfff};
130
131 static GList *compose_list = NULL;
132
133 static Compose *compose_create                  (PrefsAccount   *account,
134                                                  ComposeMode     mode);
135 static void compose_toolbar_create              (Compose        *compose,
136                                                  GtkWidget      *container);
137 static GtkWidget *compose_account_option_menu_create
138                                                 (Compose        *compose);
139 static void compose_set_template_menu           (Compose        *compose);
140 static void compose_destroy                     (Compose        *compose);
141
142 static gint compose_parse_header                (Compose        *compose,
143                                                  MsgInfo        *msginfo);
144 static gchar *compose_parse_references          (const gchar    *ref,
145                                                  const gchar    *msgid);
146
147 static gchar *compose_quote_fmt                 (Compose        *compose,
148                                                  MsgInfo        *msginfo,
149                                                  const gchar    *fmt,
150                                                  const gchar    *qmark);
151
152 static void compose_reply_set_entry             (Compose        *compose,
153                                                  MsgInfo        *msginfo,
154                                                  gboolean        to_all,
155                                                  gboolean        to_sender,
156                                                  gboolean
157                                                  followup_and_reply_to);
158 static void compose_reedit_set_entry            (Compose        *compose,
159                                                  MsgInfo        *msginfo);
160 static void compose_insert_sig                  (Compose        *compose);
161 static void compose_insert_file                 (Compose        *compose,
162                                                  const gchar    *file);
163 static void compose_attach_append               (Compose        *compose,
164                                                  const gchar    *file,
165                                                  ContentType     cnttype);
166 static void compose_attach_append_with_type(Compose *compose,
167                                             const gchar *file,
168                                             const gchar *type,
169                                             ContentType cnttype);
170 static void compose_wrap_line                   (Compose        *compose);
171 static void compose_wrap_line_all               (Compose        *compose);
172 static void compose_set_title                   (Compose        *compose);
173
174 static PrefsAccount *compose_current_mail_account(void);
175 /* static gint compose_send                     (Compose        *compose); */
176 static gint compose_write_to_file               (Compose        *compose,
177                                                  const gchar    *file,
178                                                  gboolean        is_draft);
179 static gint compose_write_body_to_file          (Compose        *compose,
180                                                  const gchar    *file);
181 static gint compose_save_to_outbox              (Compose        *compose,
182                                                  const gchar    *file);
183 static gint compose_remove_reedit_target        (Compose        *compose);
184 static gint compose_queue                       (Compose        *compose,
185                                                  const gchar    *file);
186 static void compose_write_attach                (Compose        *compose,
187                                                  FILE           *fp);
188 static gint compose_write_headers               (Compose        *compose,
189                                                  FILE           *fp,
190                                                  const gchar    *charset,
191                                                  EncodingType    encoding,
192                                                  gboolean        is_draft);
193
194 static void compose_convert_header              (gchar          *dest,
195                                                  gint            len,
196                                                  gchar          *src,
197                                                  gint            header_len);
198 static void compose_generate_msgid              (Compose        *compose,
199                                                  gchar          *buf,
200                                                  gint            len);
201
202 static void compose_attach_info_free            (AttachInfo     *ainfo);
203 static void compose_attach_remove_selected      (Compose        *compose);
204
205 static void compose_attach_property             (Compose        *compose);
206 static void compose_attach_property_create      (gboolean       *cancelled);
207 static void attach_property_ok                  (GtkWidget      *widget,
208                                                  gboolean       *cancelled);
209 static void attach_property_cancel              (GtkWidget      *widget,
210                                                  gboolean       *cancelled);
211 static gint attach_property_delete_event        (GtkWidget      *widget,
212                                                  GdkEventAny    *event,
213                                                  gboolean       *cancelled);
214 static void attach_property_key_pressed         (GtkWidget      *widget,
215                                                  GdkEventKey    *event,
216                                                  gboolean       *cancelled);
217
218 static void compose_exec_ext_editor             (Compose           *compose);
219 static gint compose_exec_ext_editor_real        (const gchar       *file);
220 static gboolean compose_ext_editor_kill         (Compose           *compose);
221 static void compose_input_cb                    (gpointer           data,
222                                                  gint               source,
223                                                  GdkInputCondition  condition);
224 static void compose_set_ext_editor_sensitive    (Compose           *compose,
225                                                  gboolean           sensitive);
226
227 static gint calc_cursor_xpos    (GtkSText       *text,
228                                  gint            extra,
229                                  gint            char_width);
230
231 static void compose_create_header_entry (Compose *compose);
232 static void compose_add_header_entry    (Compose *compose, gchar *header, gchar *text);
233
234 /* callback functions */
235
236 static gboolean compose_edit_size_alloc (GtkEditable    *widget,
237                                          GtkAllocation  *allocation,
238                                          GtkSHRuler     *shruler);
239
240 static void toolbar_send_cb             (GtkWidget      *widget,
241                                          gpointer        data);
242 static void toolbar_send_later_cb       (GtkWidget      *widget,
243                                          gpointer        data);
244 static void toolbar_draft_cb            (GtkWidget      *widget,
245                                          gpointer        data);
246 static void toolbar_insert_cb           (GtkWidget      *widget,
247                                          gpointer        data);
248 static void toolbar_attach_cb           (GtkWidget      *widget,
249                                          gpointer        data);
250 static void toolbar_sig_cb              (GtkWidget      *widget,
251                                          gpointer        data);
252 static void toolbar_ext_editor_cb       (GtkWidget      *widget,
253                                          gpointer        data);
254 static void toolbar_linewrap_cb         (GtkWidget      *widget,
255                                          gpointer        data);
256 static void toolbar_address_cb          (GtkWidget      *widget,
257                                          gpointer        data);
258 static void template_select_cb          (gpointer        daat,
259                                          guint           action,
260                                          GtkWidget      *widget);
261
262
263 static void select_account(Compose * compose, PrefsAccount * ac);
264 static void account_activated           (GtkMenuItem    *menuitem,
265                                          gpointer        data);
266
267 static void attach_selected             (GtkCList       *clist,
268                                          gint            row,
269                                          gint            column,
270                                          GdkEvent       *event,
271                                          gpointer        data);
272 static void attach_button_pressed       (GtkWidget      *widget,
273                                          GdkEventButton *event,
274                                          gpointer        data);
275 static void attach_key_pressed          (GtkWidget      *widget,
276                                          GdkEventKey    *event,
277                                          gpointer        data);
278
279 static void compose_send_cb             (gpointer        data,
280                                          guint           action,
281                                          GtkWidget      *widget);
282 static void compose_send_later_cb       (gpointer        data,
283                                          guint           action,
284                                          GtkWidget      *widget);
285
286 static void compose_draft_cb            (gpointer        data,
287                                          guint           action,
288                                          GtkWidget      *widget);
289
290 static void compose_attach_cb           (gpointer        data,
291                                          guint           action,
292                                          GtkWidget      *widget);
293 static void compose_insert_file_cb      (gpointer        data,
294                                          guint           action,
295                                          GtkWidget      *widget);
296
297 static void compose_close_cb            (gpointer        data,
298                                          guint           action,
299                                          GtkWidget      *widget);
300
301 static void compose_address_cb          (gpointer        data,
302                                          guint           action,
303                                          GtkWidget      *widget);
304 static void compose_template_activate_cb(GtkWidget      *widget,
305                                          gpointer        data);
306
307 static void compose_ext_editor_cb       (gpointer        data,
308                                          guint           action,
309                                          GtkWidget      *widget);
310
311 static gint compose_delete_cb           (GtkWidget      *widget,
312                                          GdkEventAny    *event,
313                                          gpointer        data);
314 static void compose_destroy_cb          (GtkWidget      *widget,
315                                          Compose        *compose);
316
317 #ifdef USE_UNDO_PATCH /* DINH V. Hoa */
318 static void compose_undo_cb             (Compose        *compose);
319 static void compose_redo_cb             (Compose        *compose);
320 #endif
321 static void compose_cut_cb              (Compose        *compose);
322 static void compose_copy_cb             (Compose        *compose);
323 static void compose_paste_cb            (Compose        *compose);
324 static void compose_allsel_cb           (Compose        *compose);
325
326 static void compose_grab_focus_cb       (GtkWidget      *widget,
327                                          Compose        *compose);
328
329 #ifdef USE_UNDO_PATCH /* DINH V. Hoa */
330 static void compose_insert_text_cb(GtkEditable *editable, gchar *new_text,
331                 gint new_text_length, gint *position, Compose *compose);
332 static void compose_delete_text_cb(GtkEditable *editable, gint start_pos,
333                 gint end_pos, Compose *compose);
334 #endif
335 static void compose_changed_cb          (GtkEditable    *editable,
336                                          Compose        *compose);
337 static void compose_button_press_cb     (GtkWidget      *widget,
338                                          GdkEventButton *event,
339                                          Compose        *compose);
340 #if 0
341 static void compose_key_press_cb        (GtkWidget      *widget,
342                                          GdkEventKey    *event,
343                                          Compose        *compose);
344 #endif
345
346 static void compose_toggle_to_cb        (gpointer        data,
347                                          guint           action,
348                                          GtkWidget      *widget);
349 static void compose_toggle_cc_cb        (gpointer        data,
350                                          guint           action,
351                                          GtkWidget      *widget);
352 static void compose_toggle_bcc_cb       (gpointer        data,
353                                          guint           action,
354                                          GtkWidget      *widget);
355 static void compose_toggle_replyto_cb   (gpointer        data,
356                                          guint           action,
357                                          GtkWidget      *widget);
358 static void compose_toggle_followupto_cb(gpointer        data,
359                                          guint           action,
360                                          GtkWidget      *widget);
361 static void compose_toggle_attach_cb    (gpointer        data,
362                                          guint           action,
363                                          GtkWidget      *widget);
364 static void compose_toggle_ruler_cb     (gpointer        data,
365                                          guint           action,
366                                          GtkWidget      *widget);
367 #if USE_GPGME
368 static void compose_toggle_sign_cb      (gpointer        data,
369                                          guint           action,
370                                          GtkWidget      *widget);
371 static void compose_toggle_encrypt_cb   (gpointer        data,
372                                          guint           action,
373                                          GtkWidget      *widget);
374 #endif
375 static void compose_toggle_return_receipt_cb(gpointer data, guint action,
376                                              GtkWidget *widget);
377
378 static void compose_attach_drag_received_cb (GtkWidget          *widget,
379                                              GdkDragContext     *drag_context,
380                                              gint                x,
381                                              gint                y,
382                                              GtkSelectionData   *data,
383                                              guint               info,
384                                              guint               time,
385                                              gpointer            user_data);
386 static void compose_insert_drag_received_cb (GtkWidget          *widget,
387                                              GdkDragContext     *drag_context,
388                                              gint                x,
389                                              gint                y,
390                                              GtkSelectionData   *data,
391                                              guint               info,
392                                              guint               time,
393                                              gpointer            user_data);
394
395 static void to_activated                (GtkWidget      *widget,
396                                          Compose        *compose);
397 static void newsgroups_activated        (GtkWidget      *widget,
398                                          Compose        *compose);
399 static void subject_activated           (GtkWidget      *widget,
400                                          Compose        *compose);
401 static void cc_activated                (GtkWidget      *widget,
402                                          Compose        *compose);
403 static void bcc_activated               (GtkWidget      *widget,
404                                          Compose        *compose);
405 static void replyto_activated           (GtkWidget      *widget,
406                                          Compose        *compose);
407 static void followupto_activated        (GtkWidget      *widget,
408                                          Compose        *compose);
409 static void compose_attach_parts(Compose * compose,
410                                  MsgInfo * msginfo);
411
412 static void compose_generic_reply(MsgInfo *msginfo, gboolean quote,
413                                   gboolean to_all,
414                                   gboolean ignore_replyto,
415                                   gboolean followup_and_reply_to);
416
417 void compose_headerentry_changed_cb     (GtkWidget *entry,
418                                          compose_headerentry *headerentry);
419 void compose_headerentry_key_press_event_cb     (GtkWidget *entry,
420                                                  GdkEventKey *event,
421                                                  compose_headerentry *headerentry);
422
423 Compose * compose_generic_new (PrefsAccount     *account,
424                                const gchar      *to,
425                                FolderItem       *item);
426
427 static GtkItemFactoryEntry compose_popup_entries[] =
428 {
429         {N_("/_Add..."),        NULL, compose_attach_cb, 0, NULL},
430         {N_("/_Remove"),        NULL, compose_attach_remove_selected, 0, NULL},
431         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
432         {N_("/_Property..."),   NULL, compose_attach_property, 0, NULL}
433 };
434
435 static GtkItemFactoryEntry compose_entries[] =
436 {
437         {N_("/_File"),                          NULL, NULL, 0, "<Branch>"},
438         {N_("/_File/_Attach file"),             "<control>M", compose_attach_cb,      0, NULL},
439         {N_("/_File/_Insert file"),             "<control>I", compose_insert_file_cb, 0, NULL},
440         {N_("/_File/Insert si_gnature"),        "<control>G", compose_insert_sig,     0, NULL},
441         {N_("/_File/---"),                      NULL, NULL, 0, "<Separator>"},
442         {N_("/_File/_Close"),                   "<alt>W", compose_close_cb, 0, NULL},
443
444         {N_("/_Edit"),             NULL, NULL, 0, "<Branch>"},
445 #ifdef USE_UNDO_PATCH /* DINH V. Hoa */
446         {N_("/_Edit/_Undo"),       "<control>Z", compose_undo_cb, 0, NULL},
447         {N_("/_Edit/_Redo"),       "<control>Y", compose_redo_cb, 0, NULL},
448 #else
449         {N_("/_Edit/_Undo"),       "<control>Z", NULL, 0, NULL},
450         {N_("/_Edit/_Redo"),       "<control>Y", NULL, 0, NULL},
451 #endif
452         {N_("/_Edit/---"),         NULL, NULL, 0, "<Separator>"},
453         {N_("/_Edit/Cu_t"),        "<control>X", compose_cut_cb,    0, NULL},
454         {N_("/_Edit/_Copy"),       "<control>C", compose_copy_cb,   0, NULL},
455         {N_("/_Edit/_Paste"),      "<control>V", compose_paste_cb,  0, NULL},
456         {N_("/_Edit/Select _all"), "<control>A", compose_allsel_cb, 0, NULL},
457         {N_("/_Edit/---"),         NULL, NULL, 0, "<Separator>"},
458         {N_("/_Edit/_Wrap current paragraph"), "<alt>L", compose_wrap_line, 0, NULL},
459         {N_("/_Edit/Wrap all long _lines"),
460                         "<shift><alt>L", compose_wrap_line_all, 0, NULL},
461         {N_("/_Edit/Edit with e_xternal editor"),
462                         "<alt>X", compose_ext_editor_cb, 0, NULL},
463
464         {N_("/_Message"),               NULL, NULL, 0, "<Branch>"},
465         {N_("/_Message/_Send"),         "<control>Return",
466                                         compose_send_cb, 0, NULL},
467         {N_("/_Message/Send _later"),   "<shift><alt>S",
468                                         compose_send_later_cb,  0, NULL},
469         {N_("/_Message/Save to _draft folder"),
470                                         "<alt>D", compose_draft_cb, 0, NULL},
471 #if 0 /* NEW COMPOSE GUI */
472         {N_("/_Message/---"),           NULL, NULL, 0, "<Separator>"},
473         {N_("/_Message/_To"),           NULL, compose_toggle_to_cb     , 0, "<ToggleItem>"},
474         {N_("/_Message/_Cc"),           NULL, compose_toggle_cc_cb     , 0, "<ToggleItem>"},
475         {N_("/_Message/_Bcc"),          NULL, compose_toggle_bcc_cb    , 0, "<ToggleItem>"},
476         {N_("/_Message/_Reply to"),     NULL, compose_toggle_replyto_cb, 0, "<ToggleItem>"},
477         {N_("/_Message/---"),           NULL, NULL, 0, "<Separator>"},
478         {N_("/_Message/_Followup to"),  NULL, compose_toggle_followupto_cb, 0, "<ToggleItem>"},
479         {N_("/_Message/---"),           NULL, NULL, 0, "<Separator>"},
480         {N_("/_Message/_Attach"),       NULL, compose_toggle_attach_cb, 0, "<ToggleItem>"},
481 #endif
482 #if USE_GPGME
483         {N_("/_Message/---"),           NULL, NULL, 0, "<Separator>"},
484         {N_("/_Message/Si_gn"),         NULL, compose_toggle_sign_cb   , 0, "<ToggleItem>"},
485         {N_("/_Message/_Encrypt"),      NULL, compose_toggle_encrypt_cb, 0, "<ToggleItem>"},
486 #endif /* USE_GPGME */
487         {N_("/_Message/---"),           NULL,           NULL,   0, "<Separator>"},
488         {N_("/_Message/_Request Return Receipt"),       NULL, compose_toggle_return_receipt_cb, 0, "<ToggleItem>"},
489         {N_("/_Tool"),                  NULL, NULL, 0, "<Branch>"},
490         {N_("/_Tool/Show _ruler"),      NULL, compose_toggle_ruler_cb, 0, "<ToggleItem>"},
491         {N_("/_Tool/_Address book"),    "<alt>A", compose_address_cb , 0, NULL},
492         {N_("/_Tool/_Template"),        NULL, NULL, 0, "<Branch>"},
493         {N_("/_Help"),                  NULL, NULL, 0, "<LastBranch>"},
494         {N_("/_Help/_About"),           NULL, about_show, 0, NULL}
495 };
496
497 static GtkTargetEntry compose_mime_types[] =
498 {
499         {"text/uri-list", 0, 0}
500 };
501
502 Compose * compose_new(PrefsAccount *account)
503 {
504         return compose_generic_new(account, NULL, NULL);
505 }
506
507 Compose * compose_new_with_recipient(PrefsAccount *account, const gchar *to)
508 {
509         return compose_generic_new(account, to, NULL);
510 }
511
512 Compose * compose_new_with_folderitem(PrefsAccount *account, FolderItem *item)
513 {
514         return compose_generic_new(account, NULL, item);
515 }
516
517 static void set_compose_entries(Compose * compose, const gchar * mailto)
518 {
519         gchar * subject = NULL;
520         gchar * to = NULL;
521         gchar * cc = NULL;
522         gchar * bcc = NULL;
523         gchar * body = NULL;
524         gchar * p;
525         gchar * tmp_mailto;
526         gchar * cur;
527         
528         Xstrdup_a(tmp_mailto, mailto, return);
529
530         cur = tmp_mailto;
531
532         p = strchr(cur, '?');
533         if (p != NULL) {
534                 * p = 0;
535                 cur = p + 1;
536         }
537         to = tmp_mailto;
538
539         while (p) {
540                 char *field, *value;
541                 
542                 field = cur;
543
544                 p = strchr(cur, '=');
545                 if (p == NULL)
546                         break;
547                 * p = 0;
548                 cur = p + 1;
549
550                 value = cur;
551
552                 p = strchr(cur, '&');
553                 if (p != NULL) {
554                         * p = 0;
555                         cur = p + 1;
556                 }
557
558                 if (value) {
559                         if (g_strcasecmp(field, "subject")==0) {
560                                 Xstrdup_a(subject, value, );
561                                 if (subject != NULL)
562                                         decode_uri(subject, value);
563                         }
564                         else if (g_strcasecmp(field, "cc")==0)
565                                 cc = value;
566                         else if (g_strcasecmp(field, "bcc")==0)
567                                 bcc = value;
568                         else if (g_strcasecmp(field, "body")==0) {
569                                 Xstrdup_a(body, value, );
570                                 if (body != NULL)
571                                         decode_uri(body, value);
572                         }
573                 }
574         }                       
575
576         if (to) {
577                 compose_entry_append(compose, to, COMPOSE_TO);
578                 /*
579                 gtk_widget_grab_focus(compose->text);
580                 */
581         }
582
583         if (subject)
584                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), subject);
585         if (cc)
586                 compose_entry_append(compose, cc, COMPOSE_CC);
587         if (bcc)
588                 compose_entry_append(compose, bcc, COMPOSE_BCC);
589         if (body) {
590                 gtk_stext_insert(GTK_STEXT(compose->text),
591                                  NULL, NULL, NULL, body, -1);
592                 gtk_stext_insert(GTK_STEXT(compose->text),
593                                  NULL, NULL, NULL, "\n", 1);
594         }
595 }       
596
597 Compose * compose_generic_new(PrefsAccount *account, const gchar *to, FolderItem *item)
598 {
599         Compose *compose;
600
601         if (item && item->prefs && item->prefs->enable_default_account)
602                 account = account_find_from_id(item->prefs->default_account);
603
604         if (!account) account = cur_account;
605         g_return_val_if_fail(account != NULL, NULL);
606
607         compose = compose_create(account, COMPOSE_NEW);
608         compose->replyinfo = NULL;
609
610         if (prefs_common.auto_sig)
611                 compose_insert_sig(compose);
612         gtk_editable_set_position(GTK_EDITABLE(compose->text), 0);
613         gtk_stext_set_point(GTK_STEXT(compose->text), 0);
614
615         if (account->protocol != A_NNTP) {
616                 if (to) {
617                         set_compose_entries(compose, to);
618
619                 } else if(item && item->prefs->enable_default_to) {
620                         compose_entry_append(compose, item->prefs->default_to, COMPOSE_TO);
621                 }
622                 if (item && item->ret_rcpt) {
623                         GtkItemFactory *ifactory;
624                 
625                         ifactory = gtk_item_factory_from_widget(compose->menubar);
626                         menu_set_toggle(ifactory, "/Message/Request Return Receipt", TRUE);
627                 }
628         } else {
629                 if (to) {
630                         compose_entry_append(compose, to, COMPOSE_NEWSGROUPS);
631                 }
632         }
633         gtk_widget_grab_focus(compose->subject_entry);
634
635         if (prefs_common.auto_exteditor)
636                 compose_exec_ext_editor(compose);
637
638         return compose;
639 }
640
641 #define CHANGE_FLAGS(msginfo) \
642 { \
643 if (msginfo->folder->folder->change_flags != NULL) \
644 msginfo->folder->folder->change_flags(msginfo->folder->folder, \
645                                       msginfo->folder, \
646                                       msginfo); \
647 }
648
649 /*
650 Compose * compose_new_followup_and_replyto(PrefsAccount *account,
651                                            const gchar *followupto, gchar * to)
652 {
653         Compose *compose;
654
655         if (!account) account = cur_account;
656         g_return_val_if_fail(account != NULL, NULL);
657         g_return_val_if_fail(account->protocol != A_NNTP, NULL);
658
659         compose = compose_create(account, COMPOSE_NEW);
660
661         if (prefs_common.auto_sig)
662                 compose_insert_sig(compose);
663         gtk_editable_set_position(GTK_EDITABLE(compose->text), 0);
664         gtk_stext_set_point(GTK_STEXT(compose->text), 0);
665
666         compose_entry_append(compose, to, COMPOSE_TO);
667         compose_entry_append(compose, followupto, COMPOSE_NEWSGROUPS);
668         gtk_widget_grab_focus(compose->subject_entry);
669
670         return compose;
671 }
672 */
673
674 void compose_reply(MsgInfo *msginfo, gboolean quote, gboolean to_all,
675                    gboolean ignore_replyto)
676 {
677         compose_generic_reply(msginfo, quote, to_all, ignore_replyto, FALSE);
678 }
679
680 void compose_followup_and_reply_to(MsgInfo *msginfo, gboolean quote,
681                                    gboolean to_all,
682                                    gboolean ignore_replyto)
683 {
684         compose_generic_reply(msginfo, quote, to_all, ignore_replyto, TRUE);
685 }
686
687 static void compose_generic_reply(MsgInfo *msginfo, gboolean quote,
688                                   gboolean to_all,
689                                   gboolean ignore_replyto,
690                                   gboolean followup_and_reply_to)
691 {
692         Compose *compose;
693         PrefsAccount *account;
694         PrefsAccount *reply_account;
695         GtkSText *text;
696
697         g_return_if_fail(msginfo != NULL);
698         g_return_if_fail(msginfo->folder != NULL);
699
700         account = NULL;
701         /* select the account set in folderitem's property (if enabled) */
702         if (msginfo->folder->prefs && msginfo->folder->prefs->enable_default_account)
703                 account = account_find_from_id(msginfo->folder->prefs->default_account);
704         
705         /* select the account for the whole folder (IMAP / NNTP) */
706         if (!account)
707                 account = msginfo->folder->folder->account;
708
709         /* select account by to: and cc: header if enabled */
710         if (prefs_common.reply_account_autosel) {
711                 if (!account && msginfo->to) {
712                         gchar *to;
713                         Xstrdup_a(to, msginfo->to, return);
714                         extract_address(to);
715                         account = account_find_from_address(to);
716                 }
717                 if (!account) {
718                         gchar cc[BUFFSIZE];
719                         if(!get_header_from_msginfo(msginfo, cc, sizeof(cc), "CC:")) { /* Found a CC header */
720                                 extract_address(cc);
721                                 account = account_find_from_address(cc);
722                         }        
723                 }
724         }
725
726         /* select current account */
727         if (!account) account = cur_account;
728         g_return_if_fail(account != NULL);
729
730         if (ignore_replyto && account->protocol == A_NNTP &&
731             !followup_and_reply_to) {
732                 reply_account =
733                         account_find_from_address(account->address);
734                 if (!reply_account)
735                         reply_account = compose_current_mail_account();
736                 if (!reply_account)
737                         return;
738         } else
739                 reply_account = account;
740
741         MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_FORWARDED);
742         MSG_SET_PERM_FLAGS(msginfo->flags, MSG_REPLIED);
743
744         CHANGE_FLAGS(msginfo);
745
746         compose = compose_create(account, COMPOSE_REPLY);
747         compose->replyinfo = procmsg_msginfo_copy(msginfo);
748
749 #if 0 /* NEW COMPOSE GUI */
750         if (followup_and_reply_to) {
751                 gtk_widget_show(compose->to_hbox);
752                 gtk_widget_show(compose->to_entry);
753                 gtk_table_set_row_spacing(GTK_TABLE(compose->table), 1, 4);
754                 compose->use_to = TRUE;
755         }
756 #endif
757         if (msginfo->folder && msginfo->folder->ret_rcpt) {
758                 GtkItemFactory *ifactory;
759         
760                 ifactory = gtk_item_factory_from_widget(compose->menubar);
761                 menu_set_toggle(ifactory, "/Message/Request Return Receipt", TRUE);
762         }
763
764         if (compose_parse_header(compose, msginfo) < 0) return;
765         compose_reply_set_entry(compose, msginfo, to_all, ignore_replyto,
766                                 followup_and_reply_to);
767
768         text = GTK_STEXT(compose->text);
769         gtk_stext_freeze(text);
770
771         if (quote) {
772                 gchar *qmark;
773                 gchar *quote_str;
774
775                 if (prefs_common.quotemark && *prefs_common.quotemark)
776                         qmark = prefs_common.quotemark;
777                 else
778                         qmark = "> ";
779
780                 quote_str = compose_quote_fmt(compose, msginfo,
781                                               prefs_common.quotefmt,
782                                               qmark);
783         }
784
785         if (prefs_common.auto_sig)
786                 compose_insert_sig(compose);
787         gtk_editable_set_position(GTK_EDITABLE(text), 0);
788         gtk_stext_set_point(text, 0);
789
790         if (quote && prefs_common.linewrap_quote) {
791                 compose_wrap_line_all(compose);
792         }
793
794         gtk_stext_thaw(text);
795         gtk_widget_grab_focus(compose->text);
796
797         if (prefs_common.auto_exteditor)
798                 compose_exec_ext_editor(compose);
799 }
800
801
802 static gchar *procmime_get_file_name(MimeInfo *mimeinfo)
803 {
804         gchar *base;
805         gchar *filename;
806
807         g_return_val_if_fail(mimeinfo != NULL, NULL);
808
809         base = mimeinfo->filename ? mimeinfo->filename
810                 : mimeinfo->name ? mimeinfo->name : NULL;
811
812         if (MIME_TEXT_HTML == mimeinfo->mime_type && base == NULL){
813                 filename = g_strdup_printf("%s%smimetmp%i.html",
814                                            get_mime_tmp_dir(),
815                                            G_DIR_SEPARATOR_S,
816                                            mimeinfo);
817                 return filename;
818         }
819         else {
820                 base = base ? base : "";
821                 base = g_basename(base);
822                 if (*base == '\0') {
823                         filename = g_strdup_printf("%s%smimetmp%i",
824                                                    get_mime_tmp_dir(),
825                                                    G_DIR_SEPARATOR_S,
826                                                    mimeinfo);
827                         return filename;
828                 }
829         }
830
831         filename = g_strconcat(get_mime_tmp_dir(), G_DIR_SEPARATOR_S,
832                                base, NULL);
833
834         return filename;
835 }
836
837 static gchar * mime_extract_file(gchar * source, MimeInfo *partinfo)
838 {
839         gchar *filename;
840
841         if (!partinfo) return;
842
843         filename = procmime_get_file_name(partinfo);
844
845         if (procmime_get_part(filename, source, partinfo) < 0)
846                 alertpanel_error
847                         (_("Can't get the part of multipart message."));
848
849         return filename;
850 }
851
852 static void compose_attach_parts(Compose * compose,
853                                  MsgInfo * msginfo)
854 {
855
856         FILE *fp;
857         gchar *file;
858         MimeInfo *mimeinfo;
859         MsgInfo *tmpmsginfo;
860         gchar *p;
861         gchar *boundary;
862         gint boundary_len = 0;
863         gchar buf[BUFFSIZE];
864         glong fpos, prev_fpos;
865         gint npart;
866         gchar * source;
867         gchar * filename;
868
869         g_return_if_fail(msginfo != NULL);
870         
871 #if USE_GPGME
872         for (;;) {
873                 if ((fp = procmsg_open_message(msginfo)) == NULL) return;
874                 mimeinfo = procmime_scan_mime_header(fp);
875                 if (!mimeinfo) break;
876
877                 if (!MSG_IS_ENCRYPTED(msginfo->flags) &&
878                     rfc2015_is_encrypted(mimeinfo)) {
879                         MSG_SET_TMP_FLAGS(msginfo->flags, MSG_ENCRYPTED);
880                 }
881                 if (MSG_IS_ENCRYPTED(msginfo->flags) &&
882                     !msginfo->plaintext_file  &&
883                     !msginfo->decryption_failed) {
884                         rfc2015_decrypt_message(msginfo, mimeinfo, fp);
885                         if (msginfo->plaintext_file &&
886                             !msginfo->decryption_failed) {
887                                 fclose(fp);
888                                 continue;
889                         }
890                 }
891                 
892                 break;
893         }
894 #else /* !USE_GPGME */
895         if ((fp = procmsg_open_message(msginfo)) == NULL) return;
896         mimeinfo = procmime_scan_mime_header(fp);
897 #endif /* USE_GPGME */
898
899         fclose(fp);
900         if (!mimeinfo) return;
901         if (mimeinfo->mime_type == MIME_TEXT)
902                 return;
903
904         if ((fp = procmsg_open_message(msginfo)) == NULL) return;
905
906         g_return_if_fail(mimeinfo != NULL);
907         g_return_if_fail(mimeinfo->mime_type != MIME_TEXT);
908
909         if (mimeinfo->mime_type == MIME_MULTIPART) {
910                 g_return_if_fail(mimeinfo->boundary != NULL);
911                 g_return_if_fail(mimeinfo->sub == NULL);
912         }
913         g_return_if_fail(fp != NULL);
914
915         boundary = mimeinfo->boundary;
916
917         if (boundary) {
918                 boundary_len = strlen(boundary);
919
920                 /* look for first boundary */
921                 while ((p = fgets(buf, sizeof(buf), fp)) != NULL)
922                         if (IS_BOUNDARY(buf, boundary, boundary_len)) break;
923                 if (!p) {
924                         fclose(fp);
925                         return;
926                 }
927         }
928
929         if ((fpos = ftell(fp)) < 0) {
930                 perror("ftell");
931                 fclose(fp);
932                 return;
933         }
934
935         for (npart = 0;; npart++) {
936                 MimeInfo *partinfo;
937                 gboolean eom = FALSE;
938
939                 prev_fpos = fpos;
940
941                 partinfo = procmime_scan_mime_header(fp);
942                 if (!partinfo) break;
943
944                 if (npart != 0)
945                         procmime_mimeinfo_insert(mimeinfo, partinfo);
946                 else
947                         procmime_mimeinfo_free(partinfo);
948
949                 /* look for next boundary */
950                 buf[0] = '\0';
951                 while ((p = fgets(buf, sizeof(buf), fp)) != NULL) {
952                         if (IS_BOUNDARY(buf, boundary, boundary_len)) {
953                                 if (buf[2 + boundary_len]     == '-' &&
954                                     buf[2 + boundary_len + 1] == '-')
955                                         eom = TRUE;
956                                 break;
957                         }
958                 }
959                 if (p == NULL)
960                         eom = TRUE;     /* broken MIME message */
961                 fpos = ftell(fp);
962
963                 partinfo->size = fpos - prev_fpos - strlen(buf);
964
965                 if (eom) break;
966         }
967
968         source = procmsg_get_message_file_path(msginfo);
969
970         g_return_if_fail(mimeinfo != NULL);
971
972         if (!mimeinfo->main && mimeinfo->parent)
973                 {
974                         filename = mime_extract_file(source, mimeinfo);
975
976                         compose_attach_append_with_type(compose, filename,
977                                                         mimeinfo->content_type,
978                                                         mimeinfo->mime_type);
979
980                         g_free(filename);
981                 }
982
983         if (mimeinfo->sub && mimeinfo->sub->children)
984                 {
985                         filename = mime_extract_file(source, mimeinfo->sub);
986
987                         compose_attach_append_with_type(compose, filename,
988                                                         mimeinfo->content_type,
989                                                         mimeinfo->sub->mime_type);
990
991                         g_free(filename);
992                 }
993
994         if (mimeinfo->children) {
995                 MimeInfo *child;
996
997                 child = mimeinfo->children;
998                 while (child) {
999                         filename = mime_extract_file(source, child);
1000
1001                         compose_attach_append_with_type(compose, filename,
1002                                                         child->content_type,
1003                                                         child->mime_type);
1004
1005                         g_free(filename);
1006
1007                         child = child->next;
1008                 }
1009         }
1010
1011         fclose(fp);
1012
1013         procmime_mimeinfo_free_all(mimeinfo);
1014 }
1015
1016
1017 #define INSERT_FW_HEADER(var, hdr) \
1018 if (msginfo->var && *msginfo->var) { \
1019         gtk_stext_insert(text, NULL, NULL, NULL, hdr, -1); \
1020         gtk_stext_insert(text, NULL, NULL, NULL, msginfo->var, -1); \
1021         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1); \
1022 }
1023
1024 Compose *compose_forward(PrefsAccount * account, MsgInfo *msginfo,
1025                          gboolean as_attach)
1026 {
1027         Compose *compose;
1028         /*      PrefsAccount *account; */
1029         GtkSText *text;
1030
1031         g_return_val_if_fail(msginfo != NULL, NULL);
1032         g_return_val_if_fail(msginfo->folder != NULL, NULL);
1033
1034         account = msginfo->folder->folder->account;
1035         if (!account && msginfo->to && prefs_common.forward_account_autosel) {
1036                 gchar *to;
1037                 Xstrdup_a(to, msginfo->to, return);
1038                 extract_address(to);
1039                 account = account_find_from_address(to);
1040         }
1041
1042         if(!account && prefs_common.forward_account_autosel) {
1043                 gchar cc[BUFFSIZE];
1044                 if(!get_header_from_msginfo(msginfo,cc,sizeof(cc),"CC:")){ /* Found a CC header */
1045                         extract_address(cc);
1046                         account = account_find_from_address(cc);
1047                 }
1048         }
1049
1050         if (account == NULL) {
1051                 account = cur_account;
1052                 /*
1053                 account = msginfo->folder->folder->account;
1054                 if (!account) account = cur_account;
1055                 */
1056         }
1057         g_return_val_if_fail(account != NULL, NULL);
1058
1059         MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_REPLIED);
1060         MSG_SET_PERM_FLAGS(msginfo->flags, MSG_FORWARDED);
1061         CHANGE_FLAGS(msginfo);
1062
1063         compose = compose_create(account, COMPOSE_FORWARD);
1064
1065         if (msginfo->subject && *msginfo->subject) {
1066                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), "Fw: ");
1067                 gtk_entry_append_text(GTK_ENTRY(compose->subject_entry),
1068                                       msginfo->subject);
1069         }
1070
1071         text = GTK_STEXT(compose->text);
1072         gtk_stext_freeze(text);
1073
1074         if (as_attach) {
1075                 gchar *msgfile;
1076
1077                 msgfile = procmsg_get_message_file_path(msginfo);
1078                 if (!is_file_exist(msgfile))
1079                         g_warning(_("%s: file not exist\n"), msgfile);
1080                 else
1081                         compose_attach_append(compose, msgfile,
1082                                               MIME_MESSAGE_RFC822);
1083
1084                 g_free(msgfile);
1085         } else {
1086                 gchar *qmark;
1087                 gchar *quote_str;
1088
1089                 if (prefs_common.fw_quotemark && *prefs_common.fw_quotemark)
1090                         qmark = prefs_common.quotemark;
1091                 else
1092                         qmark = "> ";
1093
1094                 quote_str = compose_quote_fmt(compose, msginfo,
1095                                               prefs_common.fw_quotefmt, qmark);
1096                 compose_attach_parts(compose, msginfo);
1097         }
1098
1099         if (prefs_common.auto_sig)
1100                 compose_insert_sig(compose);
1101         gtk_editable_set_position(GTK_EDITABLE(compose->text), 0);
1102         gtk_stext_set_point(GTK_STEXT(compose->text), 0);
1103
1104         gtk_stext_thaw(text);
1105 #if 0 /* NEW COMPOSE GUI */
1106         if (account->protocol != A_NNTP)
1107                 gtk_widget_grab_focus(compose->to_entry);
1108         else
1109                 gtk_widget_grab_focus(compose->newsgroups_entry);
1110 #endif
1111         gtk_widget_grab_focus(compose->header_last->entry);
1112
1113         if (prefs_common.auto_exteditor)
1114                 compose_exec_ext_editor(compose);
1115
1116         return compose;
1117 }
1118
1119 #undef INSERT_FW_HEADER
1120
1121 Compose * compose_forward_multiple(PrefsAccount * account, 
1122                           GSList *msginfo_list) 
1123 {
1124         Compose *compose;
1125         GtkSText *text;
1126         GSList *msginfo;
1127         gchar *msgfile;
1128
1129         g_return_val_if_fail(msginfo_list != NULL, NULL);
1130         
1131         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next) {
1132                 if ( ((MsgInfo *)msginfo->data)->folder == NULL )
1133                         return NULL;
1134         }
1135
1136         if (account == NULL) {
1137                 account = cur_account;
1138                 /*
1139                 account = msginfo->folder->folder->account;
1140                 if (!account) account = cur_account;
1141                 */
1142         }
1143         g_return_val_if_fail(account != NULL, NULL);
1144
1145         compose = compose_create(account, COMPOSE_FORWARD);
1146
1147         text = GTK_STEXT(compose->text);
1148         gtk_stext_freeze(text);
1149
1150         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next) {
1151                 msgfile = procmsg_get_message_file_path((MsgInfo *)msginfo->data);
1152                 if (!is_file_exist(msgfile))
1153                         g_warning(_("%s: file not exist\n"), msgfile);
1154                 else
1155                         compose_attach_append(compose, msgfile,
1156                                 MIME_MESSAGE_RFC822);
1157                 g_free(msgfile);
1158         }
1159
1160         if (prefs_common.auto_sig)
1161                 compose_insert_sig(compose);
1162         gtk_editable_set_position(GTK_EDITABLE(compose->text), 0);
1163         gtk_stext_set_point(GTK_STEXT(compose->text), 0);
1164
1165         gtk_stext_thaw(text);
1166 #if 0 /* NEW COMPOSE GUI */
1167         if (account->protocol != A_NNTP)
1168                 gtk_widget_grab_focus(compose->to_entry);
1169         else
1170                 gtk_widget_grab_focus(compose->newsgroups_entry);
1171 #endif
1172
1173         return compose;
1174 }
1175
1176 void compose_reedit(MsgInfo *msginfo)
1177 {
1178         Compose *compose;
1179         PrefsAccount *account;
1180         GtkSText *text;
1181         FILE *fp;
1182         gchar buf[BUFFSIZE];
1183
1184         g_return_if_fail(msginfo != NULL);
1185         g_return_if_fail(msginfo->folder != NULL);
1186
1187         account = msginfo->folder->folder->account;
1188
1189         if(!account&& prefs_common.reedit_account_autosel) {
1190                 gchar from[BUFFSIZE];
1191                 if(!get_header_from_msginfo(msginfo,from,sizeof(from),"FROM:")){ /* Found a FROM header */
1192                         extract_address(from);
1193                         account = account_find_from_address(from);
1194                 }
1195         }
1196         if (!account) account = cur_account;
1197         g_return_if_fail(account != NULL);
1198
1199         compose = compose_create(account, COMPOSE_REEDIT);
1200         compose->targetinfo = procmsg_msginfo_copy(msginfo);
1201
1202         if (compose_parse_header(compose, msginfo) < 0) return;
1203         compose_reedit_set_entry(compose, msginfo);
1204
1205         text = GTK_STEXT(compose->text);
1206         gtk_stext_freeze(text);
1207
1208         if ((fp = procmime_get_first_text_content(msginfo)) == NULL)
1209                 g_warning(_("Can't get text part\n"));
1210         else {
1211                 while (fgets(buf, sizeof(buf), fp) != NULL)
1212                         gtk_stext_insert(text, NULL, NULL, NULL, buf, -1);
1213                 fclose(fp);
1214         }
1215         compose_attach_parts(compose, msginfo);
1216
1217         gtk_stext_thaw(text);
1218         gtk_widget_grab_focus(compose->text);
1219
1220         if (prefs_common.auto_exteditor)
1221                 compose_exec_ext_editor(compose);
1222 }
1223
1224 GList *compose_get_compose_list(void)
1225 {
1226         return compose_list;
1227 }
1228
1229 void compose_entry_append(Compose *compose, const gchar *address,
1230                           ComposeEntryType type)
1231 {
1232         GtkEntry *entry;
1233         const gchar *text;
1234         gchar *header;
1235
1236         if (!address || *address == '\0') return;
1237
1238 #if 0 /* NEW COMPOSE GUI */
1239         switch (type) {
1240         case COMPOSE_CC:
1241                 entry = GTK_ENTRY(compose->cc_entry);
1242                 break;
1243         case COMPOSE_BCC:
1244                 entry = GTK_ENTRY(compose->bcc_entry);
1245                 break;
1246         case COMPOSE_NEWSGROUPS:
1247                 entry = GTK_ENTRY(compose->newsgroups_entry);
1248                 break;
1249         case COMPOSE_TO:
1250         default:
1251                 entry = GTK_ENTRY(compose->to_entry);
1252                 break;
1253         }
1254
1255         text = gtk_entry_get_text(entry);
1256         if (*text != '\0')
1257                 gtk_entry_append_text(entry, ", ");
1258         gtk_entry_append_text(entry, address);
1259 #endif
1260
1261         switch (type) {
1262         case COMPOSE_CC:
1263                 header = N_("Cc:");
1264                 break;
1265         case COMPOSE_BCC:
1266                 header = N_("Bcc:");
1267                 break;
1268         case COMPOSE_REPLYTO:
1269                 header = N_("Reply-To:");
1270                 break;
1271         case COMPOSE_NEWSGROUPS:
1272                 header = N_("Newsgroups:");
1273                 break;
1274         case COMPOSE_FOLLOWUPTO:
1275                 header = N_( "Followup-To:");
1276                 break;
1277         case COMPOSE_TO:
1278         default:
1279                 header = N_("To:");
1280                 break;
1281         }
1282         header = prefs_common.trans_hdr ? gettext(header) : header;
1283
1284         compose_add_header_entry(compose, header, (gchar *)address);
1285 }
1286
1287 static gint compose_parse_header(Compose *compose, MsgInfo *msginfo)
1288 {
1289         static HeaderEntry hentry[] = {{"Reply-To:",       NULL, TRUE},
1290                                        {"Cc:",             NULL, FALSE},
1291                                        {"References:",     NULL, FALSE},
1292                                        {"Bcc:",            NULL, FALSE},
1293                                        {"Newsgroups:",     NULL, FALSE},
1294                                        {"Followup-To:",    NULL, FALSE},
1295                                        {"X-Mailing-List:", NULL, FALSE},
1296                                        {"X-BeenThere:",    NULL, FALSE},
1297                                        {NULL,              NULL, FALSE}};
1298
1299         enum
1300         {
1301                 H_REPLY_TO       = 0,
1302                 H_CC             = 1,
1303                 H_REFERENCES     = 2,
1304                 H_BCC            = 3,
1305                 H_NEWSGROUPS     = 4,
1306                 H_FOLLOWUP_TO    = 5,
1307                 H_X_MAILING_LIST = 6,
1308                 H_X_BEENTHERE    = 7
1309         };
1310
1311         FILE *fp;
1312
1313         g_return_val_if_fail(msginfo != NULL, -1);
1314
1315         if ((fp = procmsg_open_message(msginfo)) == NULL) return -1;
1316         procheader_get_header_fields(fp, hentry);
1317         fclose(fp);
1318
1319         if (hentry[H_REPLY_TO].body != NULL) {
1320                 conv_unmime_header_overwrite(hentry[H_REPLY_TO].body);
1321                 compose->replyto = hentry[H_REPLY_TO].body;
1322                 hentry[H_REPLY_TO].body = NULL;
1323         }
1324         if (hentry[H_CC].body != NULL) {
1325                 conv_unmime_header_overwrite(hentry[H_CC].body);
1326                 compose->cc = hentry[H_CC].body;
1327                 hentry[H_CC].body = NULL;
1328         }
1329         if (hentry[H_X_MAILING_LIST].body != NULL) {
1330                 /* this is good enough to parse debian-devel */
1331                 char * buf = g_malloc(strlen(hentry[H_X_MAILING_LIST].body) + 1);
1332                 g_return_val_if_fail(buf != NULL, -1 );
1333                 if (1 == sscanf(hentry[H_X_MAILING_LIST].body, "<%[^>]>", buf))
1334                         compose->mailinglist = g_strdup(buf);
1335                 g_free(buf);
1336                 g_free(hentry[H_X_MAILING_LIST].body);
1337                 hentry[H_X_MAILING_LIST].body = NULL ;
1338         }
1339         if (hentry[H_X_BEENTHERE].body != NULL) {
1340                 /* this is good enough to parse the sylpheed-claws lists */
1341                 char * buf = g_malloc(strlen(hentry[H_X_BEENTHERE].body) + 1);
1342                 g_return_val_if_fail(buf != NULL, -1 );
1343                 if (1 == sscanf(hentry[H_X_BEENTHERE].body, "%[^>]", buf))
1344                         compose->mailinglist = g_strdup(buf);
1345                 g_free(buf);
1346                 g_free(hentry[H_X_BEENTHERE].body);
1347                 hentry[H_X_BEENTHERE].body = NULL ;
1348         }
1349         if (hentry[H_REFERENCES].body != NULL) {
1350                 if (compose->mode == COMPOSE_REEDIT)
1351                         compose->references = hentry[H_REFERENCES].body;
1352                 else {
1353                         compose->references = compose_parse_references
1354                                 (hentry[H_REFERENCES].body, msginfo->msgid);
1355                         g_free(hentry[H_REFERENCES].body);
1356                 }
1357                 hentry[H_REFERENCES].body = NULL;
1358         }
1359         if (hentry[H_BCC].body != NULL) {
1360                 if (compose->mode == COMPOSE_REEDIT) {
1361                         conv_unmime_header_overwrite(hentry[H_BCC].body);
1362                         compose->bcc = hentry[H_BCC].body;
1363                 } else
1364                         g_free(hentry[H_BCC].body);
1365                 hentry[H_BCC].body = NULL;
1366         }
1367         if (hentry[H_NEWSGROUPS].body != NULL) {
1368                 compose->newsgroups = hentry[H_NEWSGROUPS].body;
1369                 hentry[H_NEWSGROUPS].body = NULL;
1370         }
1371         if (hentry[H_FOLLOWUP_TO].body != NULL) {
1372                 conv_unmime_header_overwrite(hentry[H_FOLLOWUP_TO].body);
1373                 compose->followup_to = hentry[H_FOLLOWUP_TO].body;
1374                 hentry[H_FOLLOWUP_TO].body = NULL;
1375         }
1376
1377         if (compose->mode == COMPOSE_REEDIT && msginfo->inreplyto)
1378                 compose->inreplyto = g_strdup(msginfo->inreplyto);
1379         else if (compose->mode != COMPOSE_REEDIT &&
1380                  msginfo->msgid && *msginfo->msgid) {
1381                 compose->inreplyto = g_strdup(msginfo->msgid);
1382
1383                 if (!compose->references) {
1384                         if (msginfo->inreplyto && *msginfo->inreplyto)
1385                                 compose->references =
1386                                         g_strdup_printf("<%s>\n\t<%s>",
1387                                                         msginfo->inreplyto,
1388                                                         msginfo->msgid);
1389                         else
1390                                 compose->references =
1391                                         g_strconcat("<", msginfo->msgid, ">",
1392                                                     NULL);
1393                 }
1394         }
1395
1396         return 0;
1397 }
1398
1399 static gchar *compose_parse_references(const gchar *ref, const gchar *msgid)
1400 {
1401         GSList *ref_id_list, *cur;
1402         GString *new_ref;
1403         gchar *new_ref_str;
1404
1405         ref_id_list = references_list_append(NULL, ref);
1406         if (!ref_id_list) return NULL;
1407         if (msgid && *msgid)
1408                 ref_id_list = g_slist_append(ref_id_list, g_strdup(msgid));
1409
1410         for (;;) {
1411                 gint len = 0;
1412
1413                 for (cur = ref_id_list; cur != NULL; cur = cur->next)
1414                         /* "<" + Message-ID + ">" + CR+LF+TAB */
1415                         len += strlen((gchar *)cur->data) + 5;
1416
1417                 if (len > MAX_REFERENCES_LEN) {
1418                         /* remove second message-ID */
1419                         if (ref_id_list && ref_id_list->next &&
1420                             ref_id_list->next->next) {
1421                                 g_free(ref_id_list->next->data);
1422                                 ref_id_list = g_slist_remove
1423                                         (ref_id_list, ref_id_list->next->data);
1424                         } else {
1425                                 slist_free_strings(ref_id_list);
1426                                 g_slist_free(ref_id_list);
1427                                 return NULL;
1428                         }
1429                 } else
1430                         break;
1431         }
1432
1433         new_ref = g_string_new("");
1434         for (cur = ref_id_list; cur != NULL; cur = cur->next) {
1435                 if (new_ref->len > 0)
1436                         g_string_append(new_ref, "\n\t");
1437                 g_string_sprintfa(new_ref, "<%s>", (gchar *)cur->data);
1438         }
1439
1440         slist_free_strings(ref_id_list);
1441         g_slist_free(ref_id_list);
1442
1443         new_ref_str = new_ref->str;
1444         g_string_free(new_ref, FALSE);
1445
1446         return new_ref_str;
1447 }
1448
1449 static gchar *compose_quote_fmt(Compose *compose, MsgInfo *msginfo,
1450                                 const gchar *fmt, const gchar *qmark)
1451 {
1452         GtkSText *text = GTK_STEXT(compose->text);
1453         gchar *quote_str = NULL;
1454         gchar *buf;
1455         gchar *p, *lastp;
1456         gint len;
1457
1458         if (qmark != NULL) {
1459                 quote_fmt_init(msginfo, NULL);
1460                 quote_fmt_scan_string(qmark);
1461                 quote_fmt_parse();
1462
1463                 buf = quote_fmt_get_buffer();
1464                 if (buf == NULL)
1465                         alertpanel_error(_("Quote mark format error."));
1466                 else
1467                         Xstrdup_a(quote_str, buf, return NULL)
1468         }
1469
1470         quote_fmt_init(msginfo, quote_str);
1471         quote_fmt_scan_string(fmt);
1472         quote_fmt_parse();
1473
1474         buf = quote_fmt_get_buffer();
1475         if (buf == NULL) {
1476                 alertpanel_error(_("Message reply/forward format error."));
1477                 return NULL;
1478         }
1479
1480         gtk_stext_freeze(text);
1481         gtk_stext_set_point(text, 0);
1482         gtk_stext_forward_delete(text, gtk_stext_get_length(text));
1483
1484         for (p = buf; *p != '\0'; ) {
1485                 lastp = strchr(p, '\n');
1486                 len = lastp ? lastp - p + 1 : -1;
1487                 gtk_stext_insert(text, NULL, NULL, NULL, p, len);
1488                 if (lastp)
1489                         p = lastp + 1;
1490                 else
1491                         break;
1492         }
1493
1494         gtk_stext_thaw(text);
1495
1496         return buf;
1497 }
1498
1499 static void compose_reply_set_entry(Compose *compose, MsgInfo *msginfo,
1500                                     gboolean to_all, gboolean ignore_replyto,
1501                                     gboolean followup_and_reply_to)
1502 {
1503         GSList *cc_list;
1504         GSList *cur;
1505         gchar *from;
1506         GHashTable *to_table;
1507
1508         g_return_if_fail(compose->account != NULL);
1509         g_return_if_fail(msginfo != NULL);
1510
1511         if ((compose->account->protocol != A_NNTP) || followup_and_reply_to)
1512                 compose_entry_append(compose,
1513                                     ((compose->mailinglist && !ignore_replyto)
1514                                      ? compose->mailinglist
1515                                      : (compose->replyto && !ignore_replyto)
1516                                      ? compose->replyto
1517                                      : msginfo->from ? msginfo->from : ""),
1518                                      COMPOSE_TO);
1519         if (compose->account->protocol == A_NNTP)
1520                 if (ignore_replyto)
1521                         compose_entry_append(compose,
1522                                              msginfo->from ? msginfo->from : "",
1523                                              COMPOSE_TO);
1524                 else
1525                         compose_entry_append(compose,
1526                                              compose->followup_to ? compose->followup_to
1527                                              : compose->newsgroups ? compose->newsgroups
1528                                              : "",
1529                                              COMPOSE_NEWSGROUPS);
1530         /*
1531                 compose_entry_append(compose,
1532                                      compose->followup_to ? compose->followup_to
1533                                      : compose->newsgroups ? compose->newsgroups
1534                                      : "",
1535                                      COMPOSE_NEWSGROUPS);
1536         */
1537
1538         if (msginfo->subject && *msginfo->subject) {
1539                 gchar *buf, *buf2, *p;
1540
1541                 buf = g_strdup(msginfo->subject);
1542                 while (!strncasecmp(buf, "Re:", 3)) {
1543                         p = buf + 3;
1544                         while (isspace(*p)) p++;
1545                         memmove(buf, p, strlen(p) + 1);
1546                 }
1547
1548                 buf2 = g_strdup_printf("Re: %s", buf);
1549                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
1550                 g_free(buf2);
1551                 g_free(buf);
1552         } else
1553                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), "Re: ");
1554
1555         if (!to_all || compose->account->protocol == A_NNTP) return;
1556
1557         from = g_strdup(compose->replyto ? compose->replyto :
1558                         msginfo->from ? msginfo->from : "");
1559         extract_address(from);
1560
1561         cc_list = address_list_append(NULL, msginfo->to);
1562         cc_list = address_list_append(cc_list, compose->cc);
1563
1564         to_table = g_hash_table_new(g_str_hash, g_str_equal);
1565         g_hash_table_insert(to_table, from, GINT_TO_POINTER(1));
1566         if (compose->account)
1567                 g_hash_table_insert(to_table, compose->account->address,
1568                                     GINT_TO_POINTER(1));
1569
1570         /* remove address on To: and that of current account */
1571         for (cur = cc_list; cur != NULL; ) {
1572                 GSList *next = cur->next;
1573
1574                 if (g_hash_table_lookup(to_table, cur->data) != NULL)
1575                         cc_list = g_slist_remove(cc_list, cur->data);
1576                 else
1577                         g_hash_table_insert(to_table, cur->data, cur);
1578
1579                 cur = next;
1580         }
1581         g_hash_table_destroy(to_table);
1582         g_free(from);
1583
1584         if (cc_list) {
1585                 for (cur = cc_list; cur != NULL; cur = cur->next)
1586                         compose_entry_append(compose, (gchar *)cur->data,
1587                                              COMPOSE_CC);
1588                 slist_free_strings(cc_list);
1589                 g_slist_free(cc_list);
1590         }
1591 }
1592
1593 #define SET_ENTRY(entry, str) \
1594 { \
1595         if (str && *str) \
1596                 gtk_entry_set_text(GTK_ENTRY(compose->entry), str); \
1597 }
1598
1599 #define SET_ADDRESS(type, str) \
1600 { \
1601         if (str && *str) \
1602                 compose_entry_append(compose, str, type); \
1603 }
1604
1605 static void compose_reedit_set_entry(Compose *compose, MsgInfo *msginfo)
1606 {
1607         g_return_if_fail(msginfo != NULL);
1608
1609         SET_ENTRY(subject_entry, msginfo->subject);
1610         SET_ADDRESS(COMPOSE_TO, msginfo->to);
1611         SET_ADDRESS(COMPOSE_CC, compose->cc);
1612         SET_ADDRESS(COMPOSE_BCC, compose->bcc);
1613         SET_ADDRESS(COMPOSE_REPLYTO, compose->replyto);
1614
1615 #if 0 /* NEW COMPOSE GUI */
1616         if (compose->bcc) {
1617                 GtkItemFactory *ifactory;
1618                 GtkWidget *menuitem;
1619
1620                 ifactory = gtk_item_factory_from_widget(compose->menubar);
1621                 menuitem = gtk_item_factory_get_item(ifactory, "/Message/Bcc");
1622                 gtk_check_menu_item_set_active
1623                         (GTK_CHECK_MENU_ITEM(menuitem), TRUE);
1624         }
1625         if (compose->replyto) {
1626                 GtkItemFactory *ifactory;
1627                 GtkWidget *menuitem;
1628
1629                 ifactory = gtk_item_factory_from_widget(compose->menubar);
1630                 menuitem = gtk_item_factory_get_item
1631                         (ifactory, "/Message/Reply to");
1632                 gtk_check_menu_item_set_active
1633                         (GTK_CHECK_MENU_ITEM(menuitem), TRUE);
1634         }
1635 #endif
1636 }
1637
1638 #undef SET_ENTRY
1639 #undef SET_ADDRESS
1640
1641 static void compose_exec_sig(Compose *compose, gchar *sigfile)
1642 {
1643         FILE *tmpfp;
1644         pid_t thepid;
1645         gchar *sigtext;
1646         FILE  *sigprg;
1647         gchar  *buf;
1648         size_t buf_len = 128;
1649  
1650         if (strlen(sigfile) < 2)
1651           return;
1652  
1653         sigprg = popen(sigfile+1, "r");
1654         if (sigprg) {
1655
1656                 buf = g_malloc(buf_len);
1657
1658                 if (!buf) {
1659                         gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL, \
1660                         "Unable to insert signature (malloc failed)\n", -1);
1661
1662                         pclose(sigprg);
1663                         return;
1664                 }
1665
1666                 while (!feof(sigprg)) {
1667                         bzero(buf, buf_len);
1668                         fread(buf, buf_len-1, 1, sigprg);
1669                         gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL, buf, -1);
1670                 }
1671
1672                 g_free(buf);
1673                 pclose(sigprg);
1674         }
1675         else
1676         {
1677                 gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL, \
1678                 "Can't exec file: ", -1);
1679                 gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL, \
1680                 sigfile+1, -1);
1681         }
1682 }
1683
1684 static void compose_insert_sig(Compose *compose)
1685 {
1686         gchar *sigfile;
1687
1688         if (compose->account && compose->account->sig_path)
1689                 sigfile = g_strdup(compose->account->sig_path);
1690         else {
1691                 sigfile = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
1692                                       DEFAULT_SIGNATURE, NULL);
1693         }
1694
1695         if (!is_file_or_fifo_exist(sigfile) & (sigfile[0] != '|')) {
1696                 g_free(sigfile);
1697                 return;
1698         }
1699
1700         gtk_stext_set_point(GTK_STEXT(compose->text),
1701                             gtk_stext_get_length(GTK_STEXT(compose->text)));
1702
1703         gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL, "\n\n", 2);
1704         if (prefs_common.sig_sep) {
1705                 gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL,
1706                                 prefs_common.sig_sep, -1);
1707                 gtk_stext_insert(GTK_STEXT(compose->text), NULL, NULL, NULL,
1708                                 "\n", 1);
1709         }
1710
1711         if (sigfile[0] == '|')
1712         {
1713                 compose_exec_sig(compose, sigfile);
1714         }
1715         else
1716         {
1717                 compose_insert_file(compose, sigfile);
1718         }
1719         g_free(sigfile);
1720 }
1721
1722 static void compose_insert_file(Compose *compose, const gchar *file)
1723 {
1724         GtkSText *text = GTK_STEXT(compose->text);
1725         gchar buf[BUFFSIZE];
1726         gint len;
1727         FILE *fp;
1728
1729         g_return_if_fail(file != NULL);
1730
1731         if ((fp = fopen(file, "r")) == NULL) {
1732                 FILE_OP_ERROR(file, "fopen");
1733                 return;
1734         }
1735
1736         gtk_stext_freeze(text);
1737
1738         while (fgets(buf, sizeof(buf), fp) != NULL) {
1739                 /* Strip <CR> if DOS/Windoze file, replace <CR> with <LF> if MAC file */
1740                 len = strlen(buf);
1741                 if (len > 1 && buf[len - 2] == '\r' && buf[len - 1] == '\n') {
1742                         buf[len - 2] = '\n';
1743                         buf[len - 1] = '\0';
1744                 } else {
1745                         while (--len > 0)
1746                                 if (buf[len] == '\r')
1747                                         buf[len] = '\n';
1748                 }
1749
1750                 gtk_stext_insert(text, NULL, NULL, NULL, buf, -1);
1751         }
1752
1753         gtk_stext_thaw(text);
1754
1755         fclose(fp);
1756 }
1757
1758 static void compose_attach_info(Compose * compose, AttachInfo * ainfo,
1759                                 ContentType cnttype)
1760 {
1761         gchar *text[N_ATTACH_COLS];
1762         gint row;
1763
1764         text[COL_MIMETYPE] = ainfo->content_type;
1765         text[COL_SIZE] = to_human_readable(ainfo->size);
1766         text[COL_NAME] = ainfo->name;
1767
1768         row = gtk_clist_append(GTK_CLIST(compose->attach_clist), text);
1769         gtk_clist_set_row_data(GTK_CLIST(compose->attach_clist), row, ainfo);
1770
1771         if (cnttype != MIME_MESSAGE_RFC822)
1772                 compose_changed_cb(NULL, compose);
1773 }
1774
1775 static void compose_attach_append_with_type(Compose *compose,
1776                                             const gchar *file,
1777                                             const gchar *type,
1778                                             ContentType cnttype)
1779 {
1780         AttachInfo *ainfo;
1781         off_t size;
1782
1783         if (!is_file_exist(file)) {
1784                 g_warning(_("File %s doesn't exist\n"), file);
1785                 return;
1786         }
1787         if ((size = get_file_size(file)) < 0) {
1788                 g_warning(_("Can't get file size of %s\n"), file);
1789                 return;
1790         }
1791         if (size == 0) {
1792                 alertpanel_notice(_("File %s is empty\n"), file);
1793                 return;
1794         }
1795 #if 0 /* NEW COMPOSE GUI */
1796         if (!compose->use_attach) {
1797                 GtkItemFactory *ifactory;
1798                 GtkWidget *menuitem;
1799
1800                 ifactory = gtk_item_factory_from_widget(compose->menubar);
1801                 menuitem = gtk_item_factory_get_item(ifactory,
1802                                                      "/Message/Attach");
1803                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
1804                                                TRUE);
1805         }
1806 #endif
1807         ainfo = g_new0(AttachInfo, 1);
1808         ainfo->file = g_strdup(file);
1809
1810         if (cnttype == MIME_MESSAGE_RFC822) {
1811                 ainfo->encoding = ENC_7BIT;
1812                 ainfo->name = g_strdup_printf(_("Message: %s"),
1813                                               g_basename(file));
1814         } else {
1815                 ainfo->encoding = ENC_BASE64;
1816                 ainfo->name = g_strdup(g_basename(file));
1817         }
1818
1819         ainfo->content_type = g_strdup(type);
1820         ainfo->size = size;
1821
1822         compose_attach_info(compose, ainfo, cnttype);
1823 }
1824
1825 static void compose_attach_append(Compose *compose, const gchar *file,
1826                                   ContentType cnttype)
1827 {
1828         AttachInfo *ainfo;
1829         gchar *text[N_ATTACH_COLS];
1830         off_t size;
1831         gint row;
1832
1833         if (!is_file_exist(file)) {
1834                 g_warning(_("File %s doesn't exist\n"), file);
1835                 return;
1836         }
1837         if ((size = get_file_size(file)) < 0) {
1838                 g_warning(_("Can't get file size of %s\n"), file);
1839                 return;
1840         }
1841         if (size == 0) {
1842                 alertpanel_notice(_("File %s is empty\n"), file);
1843                 return;
1844         }
1845 #if 0 /* NEW COMPOSE GUI */
1846         if (!compose->use_attach) {
1847                 GtkItemFactory *ifactory;
1848                 GtkWidget *menuitem;
1849
1850                 ifactory = gtk_item_factory_from_widget(compose->menubar);
1851                 menuitem = gtk_item_factory_get_item(ifactory,
1852                                                      "/Message/Attach");
1853                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
1854                                                TRUE);
1855         }
1856 #endif
1857         ainfo = g_new0(AttachInfo, 1);
1858         ainfo->file = g_strdup(file);
1859
1860         if (cnttype == MIME_MESSAGE_RFC822) {
1861                 ainfo->content_type = g_strdup("message/rfc822");
1862                 ainfo->encoding = ENC_7BIT;
1863                 ainfo->name = g_strdup_printf(_("Message: %s"),
1864                                               g_basename(file));
1865         } else {
1866                 ainfo->content_type = procmime_get_mime_type(file);
1867                 if (!ainfo->content_type)
1868                         ainfo->content_type =
1869                                 g_strdup("application/octet-stream");
1870                 ainfo->encoding = ENC_BASE64;
1871                 ainfo->name = g_strdup(g_basename(file));
1872         }
1873         ainfo->size = size;
1874
1875         compose_attach_info(compose, ainfo, cnttype);
1876 }
1877
1878 static void compose_wrap_line(Compose *compose)
1879 {
1880         GtkSText *text = GTK_STEXT(compose->text);
1881         gint ch_len, last_ch_len;
1882         gchar cbuf[MB_LEN_MAX], last_ch;
1883         guint text_len;
1884         guint line_end;
1885         guint quoted;
1886         gint p_start, p_end;
1887         gint line_pos, cur_pos;
1888         gint line_len, cur_len;
1889
1890 #define GET_STEXT(pos)                                                        \
1891         if (text->use_wchar)                                                 \
1892                 ch_len = wctomb(cbuf, (wchar_t)GTK_STEXT_INDEX(text, (pos))); \
1893         else {                                                               \
1894                 cbuf[0] = GTK_STEXT_INDEX(text, (pos));                       \
1895                 ch_len = 1;                                                  \
1896         }
1897
1898         gtk_stext_freeze(text);
1899
1900         text_len = gtk_stext_get_length(text);
1901
1902         /* check to see if the point is on the paragraph mark (empty line). */
1903         cur_pos = gtk_stext_get_point(text);
1904         GET_STEXT(cur_pos);
1905         if ((ch_len == 1 && *cbuf == '\n') || cur_pos == text_len) {
1906                 if (cur_pos == 0)
1907                         goto compose_end; /* on the paragraph mark */
1908                 GET_STEXT(cur_pos - 1);
1909                 if (ch_len == 1 && *cbuf == '\n')
1910                         goto compose_end; /* on the paragraph mark */
1911         }
1912
1913         /* find paragraph start. */
1914         line_end = quoted = 0;
1915         for (p_start = cur_pos; p_start >= 0; --p_start) {
1916                 GET_STEXT(p_start);
1917                 if (ch_len == 1 && *cbuf == '\n') {
1918                         if (quoted)
1919                                 goto compose_end; /* quoted part */
1920                         if (line_end) {
1921                                 p_start += 2;
1922                                 break;
1923                         }
1924                         line_end = 1;
1925                 } else {
1926                         if (ch_len == 1 && strchr(">:#", *cbuf))
1927                                 quoted = 1;
1928                         else if (ch_len != 1 || !isspace(*cbuf))
1929                                 quoted = 0;
1930
1931                         line_end = 0;
1932                 }
1933         }
1934         if (p_start < 0)
1935                 p_start = 0;
1936
1937         /* find paragraph end. */
1938         line_end = 0;
1939         for (p_end = cur_pos; p_end < text_len; p_end++) {
1940                 GET_STEXT(p_end);
1941                 if (ch_len == 1 && *cbuf == '\n') {
1942                         if (line_end) {
1943                                 p_end -= 1;
1944                                 break;
1945                         }
1946                         line_end = 1;
1947                 } else {
1948                         if (line_end && ch_len == 1 && strchr(">:#", *cbuf))
1949                                 goto compose_end; /* quoted part */
1950
1951                         line_end = 0;
1952                 }
1953         }
1954         if (p_end >= text_len)
1955                 p_end = text_len;
1956
1957         if (p_start >= p_end)
1958                 goto compose_end;
1959
1960         line_len = cur_len = 0;
1961         last_ch_len = 0;
1962         last_ch = '\0';
1963         line_pos = p_start;
1964         for (cur_pos = p_start; cur_pos < p_end; cur_pos++) {
1965                 guint space = 0;
1966
1967                 GET_STEXT(cur_pos);
1968
1969                 if (ch_len < 0) {
1970                         cbuf[0] = '\0';
1971                         ch_len = 1;
1972                 }
1973
1974                 if (ch_len == 1 && isspace(*cbuf))
1975                         space = 1;
1976
1977                 if (ch_len == 1 && *cbuf == '\n') {
1978                         guint replace = 0;
1979                         if (last_ch_len == 1 && !isspace(last_ch)) {
1980                                 if (cur_pos + 1 < p_end) {
1981                                         GET_STEXT(cur_pos + 1);
1982                                         if (ch_len == 1 && !isspace(*cbuf))
1983                                                 replace = 1;
1984                                 }
1985                         }
1986                         gtk_stext_set_point(text, cur_pos + 1);
1987                         gtk_stext_backward_delete(text, 1);
1988                         if (replace) {
1989                                 gtk_stext_set_point(text, cur_pos);
1990                                 gtk_stext_insert(text, NULL, NULL, NULL, " ", 1);
1991                                 space = 1;
1992                         }
1993                         else {
1994                                 p_end--;
1995                                 cur_pos--;
1996                                 continue;
1997                         }
1998                 }
1999
2000                 last_ch_len = ch_len;
2001                 last_ch = *cbuf;
2002
2003                 if (space) {
2004                         line_pos = cur_pos + 1;
2005                         line_len = cur_len + ch_len;
2006                 }
2007
2008                 if (cur_len + ch_len > prefs_common.linewrap_len &&
2009                     line_len > 0) {
2010                         gint tlen = ch_len;
2011
2012                         GET_STEXT(line_pos - 1);
2013                         if (ch_len == 1 && isspace(*cbuf)) {
2014                                 gtk_stext_set_point(text, line_pos);
2015                                 gtk_stext_backward_delete(text, 1);
2016                                 p_end--;
2017                                 cur_pos--;
2018                                 line_pos--;
2019                                 cur_len--;
2020                                 line_len--;
2021                         }
2022                         ch_len = tlen;
2023
2024                         gtk_stext_set_point(text, line_pos);
2025                         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
2026                         p_end++;
2027                         cur_pos++;
2028                         line_pos++;
2029                         cur_len = cur_len - line_len + ch_len;
2030                         line_len = 0;
2031                         continue;
2032                 }
2033
2034                 if (ch_len > 1) {
2035                         line_pos = cur_pos + 1;
2036                         line_len = cur_len + ch_len;
2037                 }
2038                 cur_len += ch_len;
2039         }
2040
2041 compose_end:
2042         gtk_stext_thaw(text);
2043
2044 #undef GET_STEXT
2045 }
2046
2047 /* return indent length */
2048 static guint get_indent_length(GtkSText *text, guint start_pos,
2049                                guint text_len) {
2050         gint indent_len = 0;
2051         gint i, ch_len;
2052         gchar cbuf[MB_CUR_MAX];
2053
2054         for (i = start_pos; i < text_len; i++) {
2055                 if (text->use_wchar)
2056                         ch_len = wctomb
2057                                 (cbuf, (wchar_t)GTK_STEXT_INDEX(text, i));
2058                 else {
2059                         cbuf[0] = GTK_STEXT_INDEX(text, i);
2060                         ch_len = 1;
2061                 }
2062                 if (ch_len > 1)
2063                         break;
2064                 /* allow space, tab, > or | */
2065                 if (cbuf[0] != ' ' && cbuf[0] != '\t' &&
2066                     cbuf[0] != '>' && cbuf[0] != '|')
2067                         break;
2068                 indent_len++;
2069         }
2070
2071         return indent_len;
2072 }
2073
2074 /* insert quotation string when line was wrapped, we know these
2075    are single byte characters */
2076 static guint ins_quote(GtkSText *text, guint quote_len, guint indent_len,
2077                        guint prev_line_pos, guint text_len,
2078                        gchar *quote_fmt) {
2079         guint i, ins_len;
2080         gchar ch;
2081
2082         if (indent_len) {
2083                 for (i = 0; i < indent_len; i++) {
2084                         ch = GTK_STEXT_INDEX(text, prev_line_pos + i);
2085                         gtk_stext_insert(text, NULL, NULL, NULL, &ch, 1);
2086                 }
2087                 ins_len = indent_len;
2088         }
2089         else {
2090                 gtk_stext_insert(text, NULL, NULL, NULL, quote_fmt, quote_len);
2091                 ins_len = quote_len;
2092         }
2093
2094         return ins_len;
2095 }
2096
2097 #undef WRAP_DEBUG
2098 #ifdef WRAP_DEBUG
2099 /* Darko: used when I debug wrapping */
2100 void dump_text(GtkSText *text, int pos, int tlen, int breakoncr)
2101 {
2102     int i;
2103     char ch;
2104
2105     printf("%d [", pos);
2106     for (i = pos; i < tlen; i++)
2107     {
2108         ch = GTK_STEXT_INDEX(text, i);
2109         if (breakoncr && ch == '\n')
2110             break;
2111         printf("%c", ch);
2112     }
2113     printf("]\n");
2114 }
2115 #endif
2116
2117 static void compose_wrap_line_all(Compose *compose)
2118 {
2119         GtkSText *text = GTK_STEXT(compose->text);
2120         guint tlen;
2121         guint line_pos = 0, cur_pos = 0, p_pos = 0;
2122         gint line_len = 0, cur_len = 0;
2123         gint ch_len;
2124         gint is_new_line = 1, do_delete = 0;
2125         guint qlen = 0, i_len = 0;
2126         guint linewrap_quote = prefs_common.linewrap_quote;
2127         guint linewrap_len = prefs_common.linewrap_len;
2128         gchar *qfmt = prefs_common.quotemark;
2129         gchar cbuf[MB_LEN_MAX];
2130
2131         gtk_stext_freeze(text);
2132
2133         /* make text buffer contiguous */
2134         gtk_stext_compact_buffer(text);
2135
2136         tlen = gtk_stext_get_length(text);
2137
2138         for (; cur_pos < tlen; cur_pos++) {
2139                 /* mark position of new line - needed for quotation wrap */
2140                 if (linewrap_quote && is_new_line) {
2141                         qlen = gtkstext_str_strcmp(text, cur_pos, tlen, qfmt);
2142                         is_new_line = 0;
2143                         if (qlen) {
2144                                 i_len = get_indent_length(text, cur_pos, tlen);
2145                         }
2146                         else
2147                                 i_len = 0;
2148                         p_pos = cur_pos;
2149 #ifdef WRAP_DEBUG
2150                         printf("new line i_len=%d qlen=%d p_pos=", i_len, qlen);
2151                         dump_text(text, p_pos, tlen, 1);
2152 #endif
2153                 }
2154
2155                 /* get character(s) at current position */
2156                 if (text->use_wchar)
2157                         ch_len = wctomb
2158                                 (cbuf, (wchar_t)GTK_STEXT_INDEX(text, cur_pos));
2159                 else {
2160                         cbuf[0] = GTK_STEXT_INDEX(text, cur_pos);
2161                         ch_len = 1;
2162                 }
2163
2164                 /* fix line length for tabs */
2165                 if (ch_len == 1 && *cbuf == '\t') {
2166                         guint tab_width = text->default_tab_width;
2167                         guint tab_offset = line_len % tab_width;
2168
2169 #ifdef WRAP_DEBUG
2170                         printf("found tab at pos=%d line_len=%d ", cur_pos,
2171                                 line_len);
2172 #endif
2173                         if (tab_offset) {
2174                                 line_len += tab_width - tab_offset - 1;
2175                                 cur_len = line_len;
2176                         }
2177 #ifdef WRAP_DEBUG
2178                         printf("new_len=%d\n", line_len);
2179 #endif
2180                 }
2181
2182                 /* we have encountered line break */
2183                 if (ch_len == 1 && *cbuf == '\n') {
2184                         gint clen;
2185                         guint ilen;
2186                         gchar cb[MB_CUR_MAX];
2187
2188 #ifdef WRAP_DEBUG
2189                         printf("found CR at %d\n", cur_pos);
2190 #endif
2191                         /* if it's just quotation + newline skip it */
2192                         if (i_len && (cur_pos + 1 < tlen)) {
2193                                 /* check if text at new line matches indent */
2194                                 ilen =  gtkstext_strncmp(text, cur_pos + 1,
2195                                                          p_pos, i_len, tlen);
2196                                 if (cur_pos + ilen < tlen) {
2197                                         if (text->use_wchar)
2198                                                 clen = wctomb(cb, (wchar_t)GTK_STEXT_INDEX(text, cur_pos + ilen + 1));
2199                                         else {
2200                                                 cb[0] = GTK_STEXT_INDEX(text,
2201                                                             cur_pos + ilen + 1);
2202                                                 clen = 1;
2203                                         }
2204                                         /* no need to join the lines */
2205                                         if ((clen == 1) && (cb[0] == '\n'))
2206                                                 do_delete = 0;
2207                                 }
2208                         }
2209
2210 #ifdef WRAP_DEBUG
2211                         printf("qlen=%d l_len=%d wrap_len=%d do_del=%d\n",
2212                                 qlen, line_len, linewrap_len, do_delete);
2213 #endif
2214                         /* should we delete to perform smart wrapping */
2215                         if (qlen && line_len < linewrap_len && do_delete) {
2216                                 /* get rid of newline */
2217                                 gtk_stext_set_point(text, cur_pos);
2218                                 gtk_stext_forward_delete(text, 1);
2219                                 tlen--;
2220
2221                                 /* if text starts with quote fmt or with
2222                                    indent string, delete them */
2223                                 if (i_len) {
2224                                         ilen =  gtkstext_strncmp(text, cur_pos,
2225                                                                  p_pos, i_len,
2226                                                                  tlen);
2227                                         if (ilen) {
2228                                                 gtk_stext_forward_delete(text,
2229                                                                          ilen);
2230                                                 tlen -= ilen;
2231                                         }
2232                                 }
2233                                 else if (qlen) {
2234                                         if (gtkstext_str_strcmp(text, cur_pos,
2235                                                                 tlen, qfmt)) {
2236                                                 gtk_stext_forward_delete(text,
2237                                                                  qlen);
2238                                                 tlen -= qlen;
2239                                         }
2240                                 }
2241
2242                                 if (text->use_wchar)
2243                                         clen = wctomb
2244                                                 (cb, (wchar_t)GTK_STEXT_INDEX(text, cur_pos));
2245                                 else {
2246                                         cb[0] = GTK_STEXT_INDEX(text, cur_pos);
2247                                         clen = 1;
2248                                 }
2249
2250                                 /* insert space if it's alphanumeric */
2251                                 if ((cur_pos != line_pos) &&
2252                                     ((clen > 1) || isalnum(cb[0]))) {
2253                                         gtk_stext_insert(text, NULL, NULL,
2254                                                          NULL, " ", 1);
2255                                         gtk_stext_compact_buffer(text);
2256                                         tlen++;
2257                                 }
2258
2259                                 /* and start over with current line */
2260                                 cur_pos = p_pos - 1;
2261                                 line_pos = cur_pos;
2262                                 line_len = cur_len = 0;
2263                                 qlen = 0;
2264                                 do_delete = 0;
2265                                 is_new_line = 1;
2266 #ifdef WRAP_DEBUG
2267                                 printf("after delete l_pos=");
2268                                 dump_text(text, line_pos, tlen, 1);
2269 #endif
2270                                 continue;
2271                         }
2272
2273                         /* mark new line beginning */
2274                         line_pos = cur_pos + 1;
2275                         line_len = cur_len = 0;
2276                         qlen = 0;
2277                         do_delete = 0;
2278                         is_new_line = 1;
2279                         continue;
2280                 }
2281
2282                 if (ch_len < 0) {
2283                         cbuf[0] = '\0';
2284                         ch_len = 1;
2285                 }
2286
2287                 /* possible line break */
2288                 if (ch_len == 1 && isspace(*cbuf)) {
2289                         line_pos = cur_pos + 1;
2290                         line_len = cur_len + ch_len;
2291                 }
2292
2293                 /* are we over wrapping length set in preferences ? */
2294                 if (cur_len + ch_len > linewrap_len) {
2295                         gint clen;
2296
2297 #ifdef WRAP_DEBUG
2298                         printf("should wrap cur_pos=%d ", cur_pos);
2299                         dump_text(text, p_pos, tlen, 1);
2300                         dump_text(text, line_pos, tlen, 1);
2301 #endif
2302                         /* force wrapping if it is one long word but not URL */
2303                         if (p_pos + i_len == line_pos)
2304                                 if (!is_url_string(text, line_pos, tlen))
2305                                         line_pos = cur_pos - 1;
2306 #ifdef WRAP_DEBUG
2307                         printf("new line_pos=%d\n", line_pos);
2308 #endif
2309
2310                         /* if next character is space delete it */
2311                         if (text->use_wchar)
2312                                 clen = wctomb(cbuf, (wchar_t)GTK_STEXT_INDEX(text, line_pos - 1));
2313                         else {
2314                                 cbuf[0] = GTK_STEXT_INDEX(text, line_pos - 1);
2315                                 clen = 1;
2316                         }
2317                         if (clen == 1 && isspace(*cbuf)) {
2318                                 if (p_pos + i_len != line_pos ||
2319                                     !is_url_string(text, line_pos, tlen)) {
2320                                         gtk_stext_set_point(text, line_pos);
2321                                         gtk_stext_backward_delete(text, 1);
2322                                         tlen--;
2323                                         cur_pos--;
2324                                         line_pos--;
2325                                         cur_len--;
2326                                         line_len--;
2327                                 }
2328                         }
2329
2330                         /* if it is URL at beginning of line don't wrap */
2331                         if (p_pos + i_len == line_pos &&
2332                             is_url_string(text, line_pos, tlen)) {
2333 #ifdef WRAP_DEBUG
2334                                 printf("found URL at ");
2335                                 dump_text(text, line_pos, tlen, 1);
2336 #endif
2337                                 continue;
2338                         }
2339
2340                         /* insert CR */
2341                         gtk_stext_set_point(text, line_pos);
2342                         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
2343                         gtk_stext_compact_buffer(text);
2344                         tlen++;
2345                         cur_pos++;
2346                         line_pos++;
2347                         cur_len = cur_len - line_len + ch_len;
2348                         line_len = 0;
2349 #ifdef WRAP_DEBUG
2350                         printf("after CR insert ");
2351                         dump_text(text, line_pos, tlen, 1);
2352 #endif
2353
2354                         /* should we insert quotation ? */
2355                         if (linewrap_quote && qlen) {
2356                                 /* only if line is not already quoted  */
2357                                 if (!gtkstext_str_strcmp(text, line_pos,
2358                                                          tlen, qfmt)) {
2359                                         guint ins_len;
2360
2361                                         if (line_pos - p_pos > i_len) {
2362                                                 ins_len = ins_quote(text,
2363                                                                     qlen,
2364                                                                     i_len,
2365                                                                     p_pos,
2366                                                                     tlen,
2367                                                                     qfmt);
2368
2369                                                 gtk_stext_compact_buffer(text);
2370                                                 tlen += ins_len;
2371                                         }
2372
2373                                         /* for loop will increase it */
2374                                         cur_pos = line_pos - 1;
2375                                         cur_len = 0;
2376                                         line_len = 0;
2377                                         /* start over with current line */
2378                                         is_new_line = 1;
2379                                         do_delete = 1;
2380 #ifdef WRAP_DEBUG
2381                                         printf("after quote insert ");
2382                                         dump_text(text, line_pos, tlen, 1);
2383 #endif
2384                                 }
2385                         }
2386                         continue;
2387                 }
2388
2389                 if (ch_len > 1) {
2390                         line_pos = cur_pos + 1;
2391                         line_len = cur_len + ch_len;
2392                 }
2393                 /* advance to next character in buffer */
2394                 cur_len += ch_len;
2395         }
2396
2397         gtk_stext_thaw(text);
2398 }
2399
2400 static void compose_set_title(Compose *compose)
2401 {
2402         gchar *str;
2403         gchar *edited;
2404
2405         edited = compose->modified ? _(" [Edited]") : "";
2406         if (compose->account && compose->account->address)
2407                 str = g_strdup_printf(_("%s - Compose message%s"),
2408                                       compose->account->address, edited);
2409         else
2410                 str = g_strdup_printf(_("Compose message%s"), edited);
2411         gtk_window_set_title(GTK_WINDOW(compose->window), str);
2412         g_free(str);
2413 }
2414
2415 /**
2416  * compose_current_mail_account:
2417  * 
2418  * Find a current mail account (the currently selected account, or the
2419  * default account, if a news account is currently selected).  If a
2420  * mail account cannot be found, display an error message.
2421  * 
2422  * Return value: Mail account, or NULL if not found.
2423  **/
2424 static PrefsAccount *
2425 compose_current_mail_account(void)
2426 {
2427         PrefsAccount *ac;
2428
2429         if (cur_account && cur_account->protocol != A_NNTP)
2430                 ac = cur_account;
2431         else {
2432                 ac = account_get_default();
2433                 if (!ac || ac->protocol == A_NNTP) {
2434                         alertpanel_error(_("Account for sending mail is not specified.\n"
2435                                            "Please select a mail account before sending."));
2436                         return NULL;
2437                 }
2438         }
2439         return ac;
2440 }
2441
2442 gboolean compose_check_for_valid_recipient(Compose *compose) {
2443         gchar *recipient_headers[] = {"To:", "Newsgroups:", "Cc:", "Bcc:", NULL};
2444         gboolean recipient_found = FALSE;
2445         GSList *list;
2446         gchar **strptr;
2447
2448         for(list = compose->header_list; list; list = list->next) {
2449                 gchar *header;
2450                 gchar *entry;
2451                 header = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(((compose_headerentry *)list->data)->combo)->entry));
2452                 entry = gtk_editable_get_chars(GTK_EDITABLE(((compose_headerentry *)list->data)->entry), 0, -1);
2453                 g_strstrip(entry);
2454                 if(entry[0] != '\0') {
2455                         for(strptr = recipient_headers; *strptr != NULL; strptr++) {
2456                                 if(!strcmp(header, (prefs_common.trans_hdr ? gettext(*strptr) : *strptr))) {
2457                                         recipient_found = TRUE;
2458                                 }
2459                         }
2460                 }
2461                 g_free(entry);
2462         }
2463         return recipient_found;
2464 }
2465
2466 gint compose_send(Compose *compose)
2467 {
2468         gchar tmp[MAXPATHLEN + 1];
2469         gint ok = 0;
2470         static gboolean lock = FALSE;
2471
2472         if (lock) return 1;
2473
2474         g_return_val_if_fail(compose->account != NULL, -1);
2475         g_return_val_if_fail(compose->orig_account != NULL, -1);
2476
2477         lock = TRUE;
2478
2479         if(!compose_check_for_valid_recipient(compose)) {
2480                 alertpanel_error(_("Recipient is not specified."));
2481                 lock = FALSE;
2482                 return 1;
2483         }
2484
2485         /* write to temporary file */
2486         g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg%d",
2487                    get_rc_dir(), G_DIR_SEPARATOR, (gint)compose);
2488
2489         if (prefs_common.linewrap_at_send)
2490                 compose_wrap_line_all(compose);
2491
2492         if (compose_write_to_file(compose, tmp, FALSE) < 0) {
2493                 lock = FALSE;
2494                 return -1;
2495         }
2496
2497         if (!compose->to_list && !compose->newsgroup_list) {
2498                 g_warning(_("can't get recipient list."));
2499                 unlink(tmp);
2500                 lock = FALSE;
2501                 return -1;
2502         }
2503
2504         if (compose->to_list) {
2505                 PrefsAccount *ac;
2506
2507 #if 0 /* NEW COMPOSE GUI */
2508                 if (compose->account->protocol != A_NNTP)
2509                         ac = compose->account;
2510                 else if (compose->orig_account->protocol != A_NNTP)
2511                         ac = compose->orig_account;
2512                 else if (cur_account && cur_account->protocol != A_NNTP)
2513                         ac = cur_account;
2514                 else {
2515                         ac = compose_current_mail_account();
2516                         if (!ac) {
2517                                 unlink(tmp);
2518                                 lock = FALSE;
2519                                 return -1;
2520                         }
2521                 }
2522 #endif
2523                 ac = compose->account;
2524
2525                 ok = send_message(tmp, ac, compose->to_list);
2526                 statusbar_pop_all();
2527         }
2528
2529         if (ok == 0 && compose->newsgroup_list) {
2530                 Folder *folder;
2531
2532                 if (compose->account->protocol == A_NNTP)
2533                         folder = FOLDER(compose->account->folder);
2534                 else
2535                         folder = FOLDER(compose->orig_account->folder);
2536
2537                 ok = news_post(folder, tmp);
2538                 if (ok < 0) {
2539                         alertpanel_error(_("Error occurred while posting the message to %s ."),
2540                                          compose->account->nntp_server);
2541                         unlink(tmp);
2542                         lock = FALSE;
2543                         return -1;
2544                 }
2545         }
2546
2547         /* queue message if failed to send */
2548         if (ok < 0) {
2549                 if (prefs_common.queue_msg) {
2550                         AlertValue val;
2551
2552                         val = alertpanel
2553                                 (_("Queueing"),
2554                                  _("Error occurred while sending the message.\n"
2555                                    "Put this message into queue folder?"),
2556                                  _("OK"), _("Cancel"), NULL);
2557                         if (G_ALERTDEFAULT == val) {
2558                                 ok = compose_queue(compose, tmp);
2559                                 if (ok < 0)
2560                                         alertpanel_error(_("Can't queue the message."));
2561                         }
2562                 } else
2563                         alertpanel_error(_("Error occurred while sending the message."));
2564         } else {
2565                 if (compose->mode == COMPOSE_REEDIT) {
2566                         compose_remove_reedit_target(compose);
2567                         if (compose->targetinfo)
2568                                 folderview_update_item
2569                                         (compose->targetinfo->folder, TRUE);
2570                 }
2571         }
2572
2573         /* save message to outbox */
2574         if (ok == 0 && prefs_common.savemsg) {
2575                 if (compose_save_to_outbox(compose, tmp) < 0)
2576                         alertpanel_error
2577                                 (_("Can't save the message to outbox."));
2578         }
2579
2580         unlink(tmp);
2581         lock = FALSE;
2582         return ok;
2583 }
2584
2585 static gboolean compose_use_attach(Compose *compose) {
2586     return(gtk_clist_get_row_data(GTK_CLIST(compose->attach_clist), 0) != NULL);
2587 }
2588
2589 static gint compose_write_to_file(Compose *compose, const gchar *file,
2590                                   gboolean is_draft)
2591 {
2592         FILE *fp;
2593         size_t len;
2594         gchar *chars;
2595         gchar *buf;
2596         const gchar *out_codeset;
2597         EncodingType encoding;
2598
2599         if ((fp = fopen(file, "w")) == NULL) {
2600                 FILE_OP_ERROR(file, "fopen");
2601                 return -1;
2602         }
2603
2604         /* chmod for security */
2605         if (change_file_mode_rw(fp, file) < 0) {
2606                 FILE_OP_ERROR(file, "chmod");
2607                 g_warning(_("can't change file mode\n"));
2608         }
2609
2610         /* get all composed text */
2611         chars = gtk_editable_get_chars(GTK_EDITABLE(compose->text), 0, -1);
2612         len = strlen(chars);
2613         if (is_ascii_str(chars)) {
2614                 buf = g_strdup(chars);
2615                 out_codeset = CS_US_ASCII;
2616                 encoding = ENC_7BIT;
2617         } else {
2618                 const gchar *src_codeset;
2619
2620                 out_codeset = conv_get_outgoing_charset_str();
2621                 if (!strcasecmp(out_codeset, CS_US_ASCII))
2622                         out_codeset = CS_ISO_8859_1;
2623                 encoding = procmime_get_encoding_for_charset(out_codeset);
2624
2625                 src_codeset = conv_get_current_charset_str();
2626                 /* if current encoding is US-ASCII, set it the same as
2627                    outgoing one to prevent code conversion failure */
2628                 if (!strcasecmp(src_codeset, CS_US_ASCII))
2629                         src_codeset = out_codeset;
2630
2631                 debug_print("src encoding = %s, out encoding = %s, transfer encoding = %s\n",
2632                             src_codeset, out_codeset, procmime_get_encoding_str(encoding));
2633
2634                 buf = conv_codeset_strdup(chars, src_codeset, out_codeset);
2635                 if (!buf) {
2636                         g_free(chars);
2637                         fclose(fp);
2638                         unlink(file);
2639                         alertpanel_error(_("Can't convert the codeset of the message."));
2640                         return -1;
2641                 }
2642         }
2643         g_free(chars);
2644
2645         /* write headers */
2646         if (compose_write_headers
2647                 (compose, fp, out_codeset, encoding, is_draft) < 0) {
2648                 g_warning(_("can't write headers\n"));
2649                 fclose(fp);
2650                 /* unlink(file); */
2651                 g_free(buf);
2652                 return -1;
2653         }
2654
2655         if (compose_use_attach(compose)) {
2656 #if USE_GPGME
2657             /* This prolog message is ignored by mime software and
2658              * because it would make our signing/encryption task
2659              * tougher, we don't emit it in that case */
2660             if (!compose->use_signing && !compose->use_encryption)
2661 #endif
2662                 fputs("This is a multi-part message in MIME format.\n", fp);
2663
2664                 fprintf(fp, "\n--%s\n", compose->boundary);
2665                 fprintf(fp, "Content-Type: text/plain; charset=%s\n",
2666                         out_codeset);
2667                 fprintf(fp, "Content-Transfer-Encoding: %s\n",
2668                         procmime_get_encoding_str(encoding));
2669                 fputc('\n', fp);
2670         }
2671
2672         /* write body */
2673         len = strlen(buf);
2674         if (encoding == ENC_BASE64) {
2675                 gchar outbuf[B64_BUFFSIZE];
2676                 gint i, l;
2677
2678                 for (i = 0; i < len; i += B64_LINE_SIZE) {
2679                         l = MIN(B64_LINE_SIZE, len - i);
2680                         to64frombits(outbuf, buf + i, l);
2681                         fputs(outbuf, fp);
2682                         fputc('\n', fp);
2683                 }
2684         } else if (fwrite(buf, sizeof(gchar), len, fp) != len) {
2685                 FILE_OP_ERROR(file, "fwrite");
2686                 fclose(fp);
2687                 unlink(file);
2688                 g_free(buf);
2689                 return -1;
2690         }
2691         g_free(buf);
2692
2693         if (compose_use_attach(compose))
2694                 compose_write_attach(compose, fp);
2695
2696         if (fclose(fp) == EOF) {
2697                 FILE_OP_ERROR(file, "fclose");
2698                 unlink(file);
2699                 return -1;
2700         }
2701
2702 #if USE_GPGME
2703         if (compose->use_signing) {
2704                 if (rfc2015_sign(file, compose->account) < 0) {
2705                         unlink(file);
2706                         return -1;
2707                 }
2708         }
2709         if (compose->use_encryption) {
2710                 if (rfc2015_encrypt(file, compose->to_list) < 0) {
2711                         unlink(file);
2712                         return -1;
2713                 }
2714         }
2715 #endif /* USE_GPGME */
2716
2717         return 0;
2718 }
2719
2720 static gint compose_write_body_to_file(Compose *compose, const gchar *file)
2721 {
2722         FILE *fp;
2723         size_t len;
2724         gchar *chars;
2725
2726         if ((fp = fopen(file, "w")) == NULL) {
2727                 FILE_OP_ERROR(file, "fopen");
2728                 return -1;
2729         }
2730
2731         /* chmod for security */
2732         if (change_file_mode_rw(fp, file) < 0) {
2733                 FILE_OP_ERROR(file, "chmod");
2734                 g_warning(_("can't change file mode\n"));
2735         }
2736
2737         chars = gtk_editable_get_chars(GTK_EDITABLE(compose->text), 0, -1);
2738
2739         /* write body */
2740         len = strlen(chars);
2741         if (fwrite(chars, sizeof(gchar), len, fp) != len) {
2742                 FILE_OP_ERROR(file, "fwrite");
2743                 g_free(chars);
2744                 fclose(fp);
2745                 unlink(file);
2746                 return -1;
2747         }
2748
2749         g_free(chars);
2750
2751         if (fclose(fp) == EOF) {
2752                 FILE_OP_ERROR(file, "fclose");
2753                 unlink(file);
2754                 return -1;
2755         }
2756         return 0;
2757 }
2758
2759 static gint compose_save_to_outbox(Compose *compose, const gchar *file)
2760 {
2761         FolderItem *outbox;
2762         gchar *path;
2763         gint num;
2764         FILE *fp;
2765
2766         debug_print(_("saving sent message...\n"));
2767
2768         outbox = folder_get_default_outbox();
2769         path = folder_item_get_path(outbox);
2770         if (!is_dir_exist(path))
2771                 make_dir_hier(path);
2772
2773         folder_item_scan(outbox);
2774         if ((num = folder_item_add_msg(outbox, file, FALSE)) < 0) {
2775                 g_free(path);
2776                 g_warning(_("can't save message\n"));
2777                 return -1;
2778         }
2779
2780         if ((fp = procmsg_open_mark_file(path, TRUE)) == NULL)
2781                 g_warning(_("can't open mark file\n"));
2782         else {
2783                 MsgInfo newmsginfo;
2784
2785                 newmsginfo.msgnum = num;
2786                 newmsginfo.flags.perm_flags = 0;
2787                 newmsginfo.flags.tmp_flags = 0;
2788                 procmsg_write_flags(&newmsginfo, fp);
2789                 fclose(fp);
2790         }
2791         g_free(path);
2792
2793         return 0;
2794 }
2795
2796 static gint compose_remove_reedit_target(Compose *compose)
2797 {
2798         FolderItem *item;
2799         MsgInfo *msginfo = compose->targetinfo;
2800
2801         g_return_val_if_fail(compose->mode == COMPOSE_REEDIT, -1);
2802         if (!msginfo) return -1;
2803
2804         item = msginfo->folder;
2805         g_return_val_if_fail(item != NULL, -1);
2806
2807         folder_item_scan(item);
2808         if (procmsg_msg_exist(msginfo) &&
2809             (item->stype == F_DRAFT || item->stype == F_QUEUE)) {
2810                 if (folder_item_remove_msg(item, msginfo->msgnum) < 0) {
2811                         g_warning(_("can't remove the old message\n"));
2812                         return -1;
2813                 }
2814         }
2815
2816         return 0;
2817 }
2818
2819 static gint compose_queue(Compose *compose, const gchar *file)
2820 {
2821         FolderItem *queue;
2822         gchar *tmp, *queue_path;
2823         FILE *fp, *src_fp;
2824         GSList *cur;
2825         gchar buf[BUFFSIZE];
2826         gint num;
2827
2828         debug_print(_("queueing message...\n"));
2829         g_return_val_if_fail(compose->to_list != NULL, -1);
2830         g_return_val_if_fail(compose->account != NULL, -1);
2831
2832         tmp = g_strdup_printf("%s%cqueue.%d", g_get_tmp_dir(),
2833                               G_DIR_SEPARATOR, (gint)compose);
2834         if ((fp = fopen(tmp, "w")) == NULL) {
2835                 FILE_OP_ERROR(tmp, "fopen");
2836                 g_free(tmp);
2837                 return -1;
2838         }
2839         if ((src_fp = fopen(file, "r")) == NULL) {
2840                 FILE_OP_ERROR(file, "fopen");
2841                 fclose(fp);
2842                 unlink(tmp);
2843                 g_free(tmp);
2844                 return -1;
2845         }
2846         if (change_file_mode_rw(fp, tmp) < 0) {
2847                 FILE_OP_ERROR(tmp, "chmod");
2848                 g_warning(_("can't change file mode\n"));
2849         }
2850
2851         /* queueing variables */
2852         fprintf(fp, "AF:\n");
2853         fprintf(fp, "NF:0\n");
2854         fprintf(fp, "PS:10\n");
2855         fprintf(fp, "SRH:1\n");
2856         fprintf(fp, "SFN:\n");
2857         fprintf(fp, "DSR:\n");
2858         if (compose->msgid)
2859                 fprintf(fp, "MID:<%s>\n", compose->msgid);
2860         else
2861                 fprintf(fp, "MID:\n");
2862         fprintf(fp, "CFG:\n");
2863         fprintf(fp, "PT:0\n");
2864         fprintf(fp, "S:%s\n", compose->account->address);
2865         fprintf(fp, "RQ:\n");
2866         if (compose->account->smtp_server)
2867                 fprintf(fp, "SSV:%s\n", compose->account->smtp_server);
2868         else
2869                 fprintf(fp, "SSV:\n");
2870         if (compose->account->nntp_server)
2871                 fprintf(fp, "NSV:%s\n", compose->account->nntp_server);
2872         else
2873                 fprintf(fp, "NSV:\n");
2874         fprintf(fp, "SSH:\n");
2875         fprintf(fp, "R:<%s>", (gchar *)compose->to_list->data);
2876         for (cur = compose->to_list->next; cur != NULL; cur = cur->next)
2877                 fprintf(fp, ",<%s>", (gchar *)cur->data);
2878         fprintf(fp, "\n");
2879         /* Sylpheed account ID */
2880         fprintf(fp, "AID:%d\n", compose->account->account_id);
2881         fprintf(fp, "\n");
2882
2883         while (fgets(buf, sizeof(buf), src_fp) != NULL) {
2884                 if (fputs(buf, fp) == EOF) {
2885                         FILE_OP_ERROR(tmp, "fputs");
2886                         fclose(fp);
2887                         fclose(src_fp);
2888                         unlink(tmp);
2889                         g_free(tmp);
2890                         return -1;
2891                 }
2892         }
2893
2894         fclose(src_fp);
2895         if (fclose(fp) == EOF) {
2896                 FILE_OP_ERROR(tmp, "fclose");
2897                 unlink(tmp);
2898                 g_free(tmp);
2899                 return -1;
2900         }
2901
2902         queue = folder_get_default_queue();
2903
2904         folder_item_scan(queue);
2905         queue_path = folder_item_get_path(queue);
2906         if (!is_dir_exist(queue_path))
2907                 make_dir_hier(queue_path);
2908         if ((num = folder_item_add_msg(queue, tmp, TRUE)) < 0) {
2909                 g_warning(_("can't queue the message\n"));
2910                 unlink(tmp);
2911                 g_free(tmp);
2912                 g_free(queue_path);
2913                 return -1;
2914         }
2915         g_free(tmp);
2916
2917         if (compose->mode == COMPOSE_REEDIT) {
2918                 compose_remove_reedit_target(compose);
2919                 if (compose->targetinfo &&
2920                     compose->targetinfo->folder != queue)
2921                         folderview_update_item
2922                                 (compose->targetinfo->folder, TRUE);
2923         }
2924
2925         if ((fp = procmsg_open_mark_file(queue_path, TRUE)) == NULL)
2926                 g_warning(_("can't open mark file\n"));
2927         else {
2928                 MsgInfo newmsginfo;
2929
2930                 newmsginfo.msgnum = num;
2931                 newmsginfo.flags.perm_flags = 0;
2932                 newmsginfo.flags.tmp_flags = 0;
2933                 procmsg_write_flags(&newmsginfo, fp);
2934                 fclose(fp);
2935         }
2936         g_free(queue_path);
2937
2938         folder_item_scan(queue);
2939         folderview_update_item(queue, TRUE);
2940
2941         return 0;
2942 }
2943
2944 static void compose_write_attach(Compose *compose, FILE *fp)
2945 {
2946         AttachInfo *ainfo;
2947         GtkCList *clist = GTK_CLIST(compose->attach_clist);
2948         gint row;
2949         FILE *attach_fp;
2950         gchar filename[BUFFSIZE];
2951         gint len;
2952
2953         for (row = 0; (ainfo = gtk_clist_get_row_data(clist, row)) != NULL;
2954              row++) {
2955                 if ((attach_fp = fopen(ainfo->file, "r")) == NULL) {
2956                         g_warning(_("Can't open file %s\n"), ainfo->file);
2957                         continue;
2958                 }
2959
2960                 fprintf(fp, "\n--%s\n", compose->boundary);
2961
2962                 if (!strcmp2(ainfo->content_type, "message/rfc822")) {
2963                         fprintf(fp, "Content-Type: %s\n", ainfo->content_type);
2964                         fprintf(fp, "Content-Disposition: inline\n");
2965                 } else {
2966                         conv_encode_header(filename, sizeof(filename),
2967                                            ainfo->name, 12);
2968                         fprintf(fp, "Content-Type: %s;\n"
2969                                     " name=\"%s\"\n",
2970                                 ainfo->content_type, filename);
2971                         fprintf(fp, "Content-Disposition: attachment;\n"
2972                                     " filename=\"%s\"\n", filename);
2973                 }
2974
2975                 fprintf(fp, "Content-Transfer-Encoding: %s\n\n",
2976                         procmime_get_encoding_str(ainfo->encoding));
2977
2978                 if (ainfo->encoding == ENC_7BIT) {
2979                         gchar buf[BUFFSIZE];
2980
2981                         while (fgets(buf, sizeof(buf), attach_fp) != NULL) {
2982                                 strcrchomp(buf);
2983                                 fputs(buf, fp);
2984                         }
2985                 } else {
2986                         gchar inbuf[B64_LINE_SIZE], outbuf[B64_BUFFSIZE];
2987
2988                         while ((len = fread(inbuf, sizeof(gchar),
2989                                             B64_LINE_SIZE, attach_fp))
2990                                == B64_LINE_SIZE) {
2991                                 to64frombits(outbuf, inbuf, B64_LINE_SIZE);
2992                                 fputs(outbuf, fp);
2993                                 fputc('\n', fp);
2994                         }
2995                         if (len > 0 && feof(attach_fp)) {
2996                                 to64frombits(outbuf, inbuf, len);
2997                                 fputs(outbuf, fp);
2998                                 fputc('\n', fp);
2999                         }
3000                 }
3001
3002                 fclose(attach_fp);
3003         }
3004
3005         fprintf(fp, "\n--%s--\n", compose->boundary);
3006 }
3007
3008 #define IS_IN_CUSTOM_HEADER(header) \
3009         (compose->account->add_customhdr && \
3010          custom_header_find(compose->account->customhdr_list, header) != NULL)
3011
3012 static gint compose_write_headers_from_headerlist(Compose *compose, 
3013                                                   FILE *fp, 
3014                                                   gchar *header,
3015                                                   GSList *(*list_append_func) (GSList *list, const gchar *str),
3016                                                   GSList **dest_list)
3017 {
3018         gchar buf[BUFFSIZE];
3019         gchar *str, *header_w_colon, *trans_hdr;
3020         gboolean first_address;
3021         GSList *list;
3022         compose_headerentry *headerentry;
3023
3024         if (IS_IN_CUSTOM_HEADER(header)) {
3025                 return 0;
3026         }
3027
3028         debug_print(_("Writing %s-header\n"), header);
3029
3030         header_w_colon = g_strconcat(header, ":", NULL);
3031         trans_hdr = (prefs_common.trans_hdr ? gettext(header_w_colon) : header_w_colon);
3032
3033         first_address = TRUE;
3034         for(list = compose->header_list; list; list = list->next) {
3035                 headerentry = ((compose_headerentry *)list->data);
3036                 if(!strcmp(trans_hdr, gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(headerentry->combo)->entry)))) {
3037                         str = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
3038                         Xstrdup_a(str, str, return -1);
3039                         g_strstrip(str);
3040                         if(str[0] != '\0') {
3041                                 if(list_append_func)
3042                                         *dest_list = list_append_func(*dest_list, str);
3043                                 compose_convert_header
3044                                         (buf, sizeof(buf), str,
3045                                         strlen(header) + 2);
3046                                 if(first_address) {
3047                                         fprintf(fp, "%s: ", header);
3048                                         first_address = FALSE;
3049                                 } else {
3050                                         fprintf(fp, ", ");
3051                                 }
3052                                 fprintf(fp, "%s", buf);
3053                         }
3054                 }
3055         }
3056         if(!first_address) {
3057                 fprintf(fp, "\n");
3058         }
3059
3060         g_free(header_w_colon);
3061
3062         return(0);
3063 }
3064
3065 static gint compose_write_headers(Compose *compose, FILE *fp,
3066                                   const gchar *charset, EncodingType encoding,
3067                                   gboolean is_draft)
3068 {
3069         gchar buf[BUFFSIZE];
3070         gchar *str;
3071         /* struct utsname utsbuf; */
3072
3073         g_return_val_if_fail(fp != NULL, -1);
3074         g_return_val_if_fail(charset != NULL, -1);
3075         g_return_val_if_fail(compose->account != NULL, -1);
3076         g_return_val_if_fail(compose->account->address != NULL, -1);
3077
3078         /* Date */
3079         if (compose->account->add_date) {
3080                 get_rfc822_date(buf, sizeof(buf));
3081                 fprintf(fp, "Date: %s\n", buf);
3082         }
3083
3084         /* From */
3085         if (!IS_IN_CUSTOM_HEADER("From")) {
3086                 if (compose->account->name && *compose->account->name) {
3087                         compose_convert_header
3088                                 (buf, sizeof(buf), compose->account->name,
3089                                  strlen("From: "));
3090                         fprintf(fp, "From: %s <%s>\n",
3091                                 buf, compose->account->address);
3092                 } else
3093                         fprintf(fp, "From: %s\n", compose->account->address);
3094         }
3095         
3096         slist_free_strings(compose->to_list);
3097         g_slist_free(compose->to_list);
3098         compose->to_list = NULL;
3099
3100         /* To */
3101         compose_write_headers_from_headerlist(compose, fp, "To", address_list_append, &compose->to_list);
3102 #if 0 /* NEW COMPOSE GUI */
3103         if (compose->use_to) {
3104                 str = gtk_entry_get_text(GTK_ENTRY(compose->to_entry));
3105                 if (*str != '\0') {
3106                         Xstrdup_a(str, str, return -1);
3107                         g_strstrip(str);
3108                         if (*str != '\0') {
3109                                 compose->to_list = address_list_append
3110                                         (compose->to_list, str);
3111                                 if (!IS_IN_CUSTOM_HEADER("To")) {
3112                                         compose_convert_header
3113                                                 (buf, sizeof(buf), str,
3114                                                  strlen("To: "));
3115                                         fprintf(fp, "To: %s\n", buf);
3116                                 }
3117                         }
3118                 }
3119         }
3120 #endif
3121         slist_free_strings(compose->newsgroup_list);
3122         g_slist_free(compose->newsgroup_list);
3123         compose->newsgroup_list = NULL;
3124
3125         /* Newsgroups */
3126         compose_write_headers_from_headerlist(compose, fp, "Newsgroups", newsgroup_list_append, &compose->newsgroup_list);
3127 #if 0 /* NEW COMPOSE GUI */
3128         str = gtk_entry_get_text(GTK_ENTRY(compose->newsgroups_entry));
3129         if (*str != '\0') {
3130                 Xstrdup_a(str, str, return -1);
3131                 g_strstrip(str);
3132                 remove_space(str);
3133                 if (*str != '\0') {
3134                         compose->newsgroup_list =
3135                                 newsgroup_list_append(compose->newsgroup_list,
3136                                                       str);
3137                         if (!IS_IN_CUSTOM_HEADER("Newsgroups")) {
3138                                 compose_convert_header(buf, sizeof(buf), str,
3139                                                        strlen("Newsgroups: "));
3140                                 fprintf(fp, "Newsgroups: %s\n", buf);
3141                         }
3142                 }
3143         }
3144 #endif
3145         /* Cc */
3146         compose_write_headers_from_headerlist(compose, fp, "Cc", address_list_append, &compose->to_list);
3147 #if 0 /* NEW COMPOSE GUI */
3148         if (compose->use_cc) {
3149                 str = gtk_entry_get_text(GTK_ENTRY(compose->cc_entry));
3150                 if (*str != '\0') {
3151                         Xstrdup_a(str, str, return -1);
3152                         g_strstrip(str);
3153                         if (*str != '\0') {
3154                                 compose->to_list = address_list_append
3155                                         (compose->to_list, str);
3156                                 if (!IS_IN_CUSTOM_HEADER("Cc")) {
3157                                         compose_convert_header
3158                                                 (buf, sizeof(buf), str,
3159                                                  strlen("Cc: "));
3160                                         fprintf(fp, "Cc: %s\n", buf);
3161                                 }
3162                         }
3163                 }
3164         }
3165 #endif
3166         /* Bcc */
3167         compose_write_headers_from_headerlist(compose, fp, "Bcc", address_list_append, &compose->to_list);
3168 #if 0 /* NEW COMPOSE GUI */
3169         if (compose->use_bcc) {
3170                 str = gtk_entry_get_text(GTK_ENTRY(compose->bcc_entry));
3171                 if (*str != '\0') {
3172                         Xstrdup_a(str, str, return -1);
3173                         g_strstrip(str);
3174                         if (*str != '\0') {
3175                                 compose->to_list = address_list_append
3176                                         (compose->to_list, str);
3177                                 compose_convert_header(buf, sizeof(buf), str,
3178                                                        strlen("Bcc: "));
3179                                 fprintf(fp, "Bcc: %s\n", buf);
3180                         }
3181                 }
3182         }
3183 #endif
3184         if (!is_draft && !compose->to_list && !compose->newsgroup_list)
3185                 return -1;
3186
3187         /* Subject */
3188         str = gtk_entry_get_text(GTK_ENTRY(compose->subject_entry));
3189         if (*str != '\0' && !IS_IN_CUSTOM_HEADER("Subject")) {
3190                 Xstrdup_a(str, str, return -1);
3191                 g_strstrip(str);
3192                 if (*str != '\0') {
3193                         compose_convert_header(buf, sizeof(buf), str,
3194                                                strlen("Subject: "));
3195                         fprintf(fp, "Subject: %s\n", buf);
3196                 }
3197         }
3198
3199         /* Message-ID */
3200         if (compose->account->gen_msgid) {
3201                 compose_generate_msgid(compose, buf, sizeof(buf));
3202                 fprintf(fp, "Message-Id: <%s>\n", buf);
3203                 compose->msgid = g_strdup(buf);
3204         }
3205
3206         /* In-Reply-To */
3207         if (compose->inreplyto && compose->to_list)
3208                 fprintf(fp, "In-Reply-To: <%s>\n", compose->inreplyto);
3209
3210         /* References */
3211         if (compose->references)
3212                 fprintf(fp, "References: %s\n", compose->references);
3213
3214         /* Followup-To */
3215         compose_write_headers_from_headerlist(compose, fp, "Followup-To", NULL, NULL);
3216 #if 0 /* NEW COMPOSE GUI */
3217         if (compose->use_followupto && !IS_IN_CUSTOM_HEADER("Followup-To")) {
3218                 str = gtk_entry_get_text(GTK_ENTRY(compose->followup_entry));
3219                 if (*str != '\0') {
3220                         Xstrdup_a(str, str, return -1);
3221                         g_strstrip(str);
3222                         remove_space(str);
3223                         if (*str != '\0') {
3224                                 compose_convert_header(buf, sizeof(buf), str,
3225                                                        strlen("Followup-To: "));
3226                                 fprintf(fp, "Followup-To: %s\n", buf);
3227                         }
3228                 }
3229         }
3230 #endif
3231         /* Reply-To */
3232         compose_write_headers_from_headerlist(compose, fp, "Reply-To", NULL, NULL);
3233 #if 0 /* NEW COMPOSE GUI */
3234         if (compose->use_replyto && !IS_IN_CUSTOM_HEADER("Reply-To")) {
3235                 str = gtk_entry_get_text(GTK_ENTRY(compose->reply_entry));
3236                 if (*str != '\0') {
3237                         Xstrdup_a(str, str, return -1);
3238                         g_strstrip(str);
3239                         if (*str != '\0') {
3240                                 compose_convert_header(buf, sizeof(buf), str,
3241                                                        strlen("Reply-To: "));
3242                                 fprintf(fp, "Reply-To: %s\n", buf);
3243                         }
3244                 }
3245         }
3246 #endif
3247         /* Organization */
3248         if (compose->account->organization &&
3249             !IS_IN_CUSTOM_HEADER("Organization")) {
3250                 compose_convert_header(buf, sizeof(buf),
3251                                        compose->account->organization,
3252                                        strlen("Organization: "));
3253                 fprintf(fp, "Organization: %s\n", buf);
3254         }
3255</