1 /*
2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
17 *
18 */
19
20 #ifdef HAVE_CONFIG_H
21 # include "config.h"
22 #include "claws-features.h"
23 #endif
24
25 #include "defs.h"
26
27 #include <glib.h>
28 #include <glib/gi18n.h>
29 #include <gtk/gtk.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <signal.h>
33 #include <sys/types.h>
34 #ifndef G_OS_WIN32
35 #include <sys/wait.h>
36 #endif
37
38 #include "send_message.h"
39 #include "session.h"
40 #include "ssl.h"
41 #include "smtp.h"
42 #include "prefs_common.h"
43 #include "prefs_account.h"
44 #include "procheader.h"
45 #include "account.h"
46 #include "progressdialog.h"
47 #include "statusbar.h"
48 #include "inputdialog.h"
49 #include "alertpanel.h"
50 #include "manage_window.h"
51 #include "logwindow.h"
52 #include "proxy.h"
53 #include "socket.h"
54 #include "utils.h"
55 #include "gtkutils.h"
56 #include "inc.h"
57 #include "log.h"
58 #include "passwordstore.h"
59 #include "file-utils.h"
60 #include "oauth2.h"
61
62 typedef struct _SendProgressDialog SendProgressDialog;
63
64 struct _SendProgressDialog
65 {
66 ProgressDialog *dialog;
67 Session *session;
68 gboolean cancelled;
69 };
70
71 static SendProgressDialog *send_dialog = NULL;
72
73 static gint send_recv_message (Session *session,
74 const gchar *msg,
75 gpointer data);
76 static gint send_send_data_progressive (Session *session,
77 guint cur_len,
78 guint total_len,
79 gpointer data);
80 static gint send_send_data_finished (Session *session,
81 guint len,
82 gpointer data);
83
84 static SendProgressDialog *send_progress_dialog_create(void);
85 static void send_progress_dialog_destroy(SendProgressDialog *dialog);
86
87 static void send_showlog_button_cb (GtkWidget *widget,
88 gpointer data);
89 static void send_cancel_button_cb (GtkWidget *widget,
90 gpointer data);
91
92 static void send_put_error (Session *session);
93
94
send_cancel(void)95 void send_cancel(void)
96 {
97 if (send_dialog)
98 send_cancel_button_cb(NULL, send_dialog);
99 }
100
send_is_active(void)101 gboolean send_is_active(void)
102 {
103 return (send_dialog != NULL);
104 }
105
send_message(const gchar * file,PrefsAccount * ac_prefs,GSList * to_list)106 gint send_message(const gchar *file, PrefsAccount *ac_prefs, GSList *to_list)
107 {
108 FILE *fp;
109 gint val;
110
111 cm_return_val_if_fail(file != NULL, -1);
112 cm_return_val_if_fail(ac_prefs != NULL, -1);
113 cm_return_val_if_fail(to_list != NULL, -1);
114
115 if ((fp = claws_fopen(file, "rb")) == NULL) {
116 FILE_OP_ERROR(file, "claws_fopen");
117 return -1;
118 }
119
120 inc_lock();
121 if (ac_prefs->use_mail_command && ac_prefs->mail_command &&
122 (*ac_prefs->mail_command)) {
123 val = send_message_local(ac_prefs->mail_command, fp);
124 claws_fclose(fp);
125 inc_unlock();
126 return val;
127 } else {
128 val = send_message_smtp(ac_prefs, to_list, fp);
129
130 claws_fclose(fp);
131 inc_unlock();
132 return val;
133 }
134 }
135
136 enum
137 {
138 Q_SENDER = 0,
139 Q_SMTPSERVER = 1,
140 Q_RECIPIENTS = 2,
141 Q_ACCOUNT_ID = 3
142 };
143
send_message_local(const gchar * command,FILE * fp)144 gint send_message_local(const gchar *command, FILE *fp)
145 {
146 gchar **argv;
147 GPid pid;
148 gint child_stdin;
149 gchar buf[BUFFSIZE];
150 gboolean err = FALSE;
151
152 cm_return_val_if_fail(command != NULL, -1);
153 cm_return_val_if_fail(fp != NULL, -1);
154
155 log_message(LOG_PROTOCOL, _("Sending message using command: %s\n"), command);
156
157 argv = strsplit_with_quote(command, " ", 0);
158
159 if (g_spawn_async_with_pipes(NULL, argv, NULL,
160 #ifdef G_OS_WIN32
161 0,
162 #else
163 G_SPAWN_DO_NOT_REAP_CHILD,
164 #endif
165 NULL, NULL,
166 &pid, &child_stdin, NULL, NULL,
167 NULL) == FALSE) {
168 g_snprintf(buf, sizeof(buf),
169 _("Couldn't execute command: %s"), command);
170 log_warning(LOG_PROTOCOL, "%s\n", buf);
171 alertpanel_error("%s", buf);
172 g_strfreev(argv);
173 return -1;
174 }
175 g_strfreev(argv);
176
177 while (claws_fgets(buf, sizeof(buf), fp) != NULL) {
178 strretchomp(buf);
179 if (buf[0] == '.' && buf[1] == '\0') {
180 if (fd_write_all(child_stdin, ".", 1) < 0) {
181 err = TRUE;
182 break;
183 }
184 }
185 if (fd_write_all(child_stdin, buf, strlen(buf)) < 0 ||
186 fd_write_all(child_stdin, "\n", 1) < 0) {
187 err = TRUE;
188 break;
189 }
190 }
191
192 fd_close(child_stdin);
193
194 #ifndef G_OS_WIN32
195 gint status;
196 waitpid(pid, &status, 0);
197 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
198 err = TRUE;
199 #endif
200
201 g_spawn_close_pid(pid);
202
203 if (err) {
204 g_snprintf(buf, sizeof(buf),
205 _("Error occurred while executing command: %s"),
206 command);
207 log_warning(LOG_PROTOCOL, "%s\n", buf);
208 alertpanel_error("%s", buf);
209 return -1;
210 }
211
212 return 0;
213 }
214
send_message_smtp_full(PrefsAccount * ac_prefs,GSList * to_list,FILE * fp,gboolean keep_session)215 gint send_message_smtp_full(PrefsAccount *ac_prefs, GSList *to_list, FILE *fp, gboolean keep_session)
216 {
217 Session *session;
218 SMTPSession *smtp_session;
219 gushort port = 0;
220 gchar buf[BUFFSIZE];
221 gint ret = 0;
222 gboolean was_inited = FALSE;
223 MsgInfo *tmp_msginfo = NULL;
224 MsgFlags flags = {0, 0};
225 long fp_pos = 0;
226 gchar spec_from[BUFFSIZE];
227 ProxyInfo *proxy_info = NULL;
228
229 cm_return_val_if_fail(ac_prefs != NULL, -1);
230 cm_return_val_if_fail(ac_prefs->address != NULL, -1);
231 cm_return_val_if_fail(ac_prefs->smtp_server != NULL, -1);
232 cm_return_val_if_fail(to_list != NULL, -1);
233 cm_return_val_if_fail(fp != NULL, -1);
234
235 /* get the From address used, not necessarily the ac_prefs',
236 * because it's editable. */
237
238 fp_pos = ftell(fp);
239 if (fp_pos < 0) {
240 perror("ftell");
241 return -1;
242 }
243 tmp_msginfo = procheader_parse_stream(fp, flags, TRUE, FALSE);
244 if (fseek(fp, fp_pos, SEEK_SET) < 0) {
245 perror("fseek");
246 return -1;
247 }
248
249 if (tmp_msginfo && tmp_msginfo->extradata && tmp_msginfo->extradata->resent_from) {
250 strncpy2(spec_from, tmp_msginfo->extradata->resent_from, BUFFSIZE-1);
251 extract_address(spec_from);
252 } else if (tmp_msginfo && tmp_msginfo->from) {
253 strncpy2(spec_from, tmp_msginfo->from, BUFFSIZE-1);
254 extract_address(spec_from);
255 } else {
256 strncpy2(spec_from, ac_prefs->address, BUFFSIZE-1);
257 }
258 if (tmp_msginfo) {
259 procmsg_msginfo_free(&tmp_msginfo);
260 }
261
262 if (!ac_prefs->session) {
263 /* we can't reuse a previously initialised session */
264 session = smtp_session_new(ac_prefs);
265 session->ssl_cert_auto_accept = ac_prefs->ssl_certs_auto_accept;
266
267 smtp_session = SMTP_SESSION(session);
268
269 if (ac_prefs->set_domain && ac_prefs->domain && strlen(ac_prefs->domain)) {
270 smtp_session->hostname = g_strdup(ac_prefs->domain);
271 } else {
272 smtp_session->hostname = NULL;
273 }
274
275 #ifdef USE_GNUTLS
276 port = ac_prefs->set_smtpport ? ac_prefs->smtpport :
277 ac_prefs->ssl_smtp == SSL_TUNNEL ? SSMTP_PORT : SMTP_PORT;
278 session->ssl_type = ac_prefs->ssl_smtp;
279 if (ac_prefs->ssl_smtp != SSL_NONE)
280 session->nonblocking = ac_prefs->use_nonblocking_ssl;
281 if (ac_prefs->set_gnutls_priority && ac_prefs->gnutls_priority &&
282 strlen(ac_prefs->gnutls_priority))
283 session->gnutls_priority = g_strdup(ac_prefs->gnutls_priority);
284 session->use_tls_sni = ac_prefs->use_tls_sni;
285 #else
286 if (ac_prefs->ssl_smtp != SSL_NONE) {
287 if (alertpanel_full(_("Insecure connection"),
288 _("This connection is configured to be secured "
289 "using SSL/TLS, but SSL/TLS is not available "
290 "in this build of Claws Mail. \n\n"
291 "Do you want to continue connecting to this "
292 "server? The communication would not be "
293 "secure."),
294 GTK_STOCK_CANCEL, _("Con_tinue connecting"), NULL,
295 ALERTFOCUS_FIRST, FALSE, NULL, ALERT_WARNING) != G_ALERTALTERNATE) {
296 session_destroy(session);
297 return -1;
298 }
299 }
300 port = ac_prefs->set_smtpport ? ac_prefs->smtpport : SMTP_PORT;
301 #endif
302
303 if(ac_prefs->use_smtp_auth && ac_prefs->smtp_auth_type == SMTPAUTH_OAUTH2)
304 oauth2_check_passwds (ac_prefs);
305
306 if (ac_prefs->use_smtp_auth) {
307 smtp_session->forced_auth_type = ac_prefs->smtp_auth_type;
308 if (ac_prefs->smtp_userid && strlen(ac_prefs->smtp_userid)) {
309 smtp_session->user = g_strdup(ac_prefs->smtp_userid);
310 if (password_get(smtp_session->user,
311 ac_prefs->smtp_server, "smtp", port,
312 &(smtp_session->pass))) {
313 /* NOP */;
314 } else if ((smtp_session->pass =
315 passwd_store_get_account(ac_prefs->account_id,
316 PWS_ACCOUNT_SEND)) == NULL) {
317 smtp_session->pass =
318 input_dialog_query_password_keep
319 (ac_prefs->smtp_server,
320 smtp_session->user,
321 &(ac_prefs->session_smtp_passwd));
322 if (!smtp_session->pass) {
323 session_destroy(session);
324 return -1;
325 }
326 }
327 } else {
328 smtp_session->user = g_strdup(ac_prefs->userid);
329 if (password_get(smtp_session->user,
330 ac_prefs->smtp_server, "smtp", port,
331 &(smtp_session->pass))) {
332 /* NOP */;
333 } else if ((smtp_session->pass = passwd_store_get_account(
334 ac_prefs->account_id, PWS_ACCOUNT_RECV)) == NULL) {
335 smtp_session->pass =
336 input_dialog_query_password_keep
337 (ac_prefs->smtp_server,
338 smtp_session->user,
339 &(ac_prefs->session_smtp_passwd));
340 if (!smtp_session->pass) {
341 session_destroy(session);
342 return -1;
343 }
344 }
345 }
346 } else {
347 smtp_session->user = NULL;
348 smtp_session->pass = NULL;
349 }
350
351 send_dialog = send_progress_dialog_create();
352 send_dialog->session = session;
353 smtp_session->dialog = send_dialog;
354
355 progress_dialog_list_set(send_dialog->dialog, 0, NULL,
356 ac_prefs->smtp_server,
357 _("Connecting"));
358
359 if (ac_prefs->pop_before_smtp
360 && (ac_prefs->protocol == A_POP3)
361 && (time(NULL) - ac_prefs->last_pop_login_time) > (60 * ac_prefs->pop_before_smtp_timeout)) {
362 g_snprintf(buf, sizeof(buf), _("Doing POP before SMTP..."));
363 log_message(LOG_PROTOCOL, "%s\n", buf);
364 progress_dialog_set_label(send_dialog->dialog, buf);
365 progress_dialog_list_set_status(send_dialog->dialog, 0, _("POP before SMTP"));
366 GTK_EVENTS_FLUSH();
367 inc_pop_before_smtp(ac_prefs);
368 }
369
370 g_snprintf(buf, sizeof(buf), _("Account '%s': Connecting to SMTP server: %s:%d..."),
371 ac_prefs->account_name, ac_prefs->smtp_server, port);
372 progress_dialog_set_label(send_dialog->dialog, buf);
373 log_message(LOG_PROTOCOL, "%s\n", buf);
374
375 session_set_recv_message_notify(session, send_recv_message, send_dialog);
376 session_set_send_data_progressive_notify
377 (session, send_send_data_progressive, send_dialog);
378 session_set_send_data_notify(session, send_send_data_finished, send_dialog);
379
380 } else {
381 /* everything is ready to start at MAIL FROM:, just
382 * reinit useful variables.
383 */
384 session = SESSION(ac_prefs->session);
385 ac_prefs->session = NULL;
386 smtp_session = SMTP_SESSION(session);
387 smtp_session->state = SMTP_HELO;
388 send_dialog = (SendProgressDialog *)smtp_session->dialog;
389 was_inited = TRUE;
390 }
391
392 /* This has to be initialised for every mail sent */
393 smtp_session->from = g_strdup(spec_from);
394 smtp_session->to_list = to_list;
395 smtp_session->cur_to = to_list;
396 smtp_session->send_data = (guchar *)get_outgoing_rfc2822_str(fp);
397 smtp_session->send_data_len = strlen((gchar *)smtp_session->send_data);
398
399 if (ac_prefs->use_proxy && ac_prefs->use_proxy_for_send) {
400 if (ac_prefs->use_default_proxy) {
401 proxy_info = (ProxyInfo *)&(prefs_common.proxy_info);
402 if (proxy_info->use_proxy_auth)
403 proxy_info->proxy_pass = passwd_store_get(PWS_CORE, PWS_CORE_PROXY,
404 PWS_CORE_PROXY_PASS);
405 } else {
406 proxy_info = (ProxyInfo *)&(ac_prefs->proxy_info);
407 if (proxy_info->use_proxy_auth)
408 proxy_info->proxy_pass = passwd_store_get_account(ac_prefs->account_id,
409 PWS_ACCOUNT_PROXY_PASS);
410 }
411 }
412 SESSION(smtp_session)->proxy_info = proxy_info;
413
414 session_set_timeout(session,
415 prefs_common.io_timeout_secs * 1000);
416 /* connect if necessary */
417 if (!was_inited && session_connect(session, ac_prefs->smtp_server,
418 port) < 0) {
419 session_destroy(session);
420 send_progress_dialog_destroy(send_dialog);
421 ac_prefs->session = NULL;
422 return -1;
423 }
424
425 debug_print("send_message_smtp(): begin event loop\n");
426
427 if (was_inited) {
428 /* as the server is quiet, start sending ourselves */
429 smtp_from(smtp_session);
430 }
431
432 while (session_is_running(session) && send_dialog->cancelled == FALSE
433 && SMTP_SESSION(session)->state != SMTP_MAIL_SENT_OK)
434 gtk_main_iteration();
435
436 if (SMTP_SESSION(session)->error_val == SM_AUTHFAIL) {
437 if (ac_prefs->session_smtp_passwd) {
438 g_free(ac_prefs->session_smtp_passwd);
439 ac_prefs->session_smtp_passwd = NULL;
440 }
441 ret = -1;
442 } else if (SMTP_SESSION(session)->state == SMTP_MAIL_SENT_OK) {
443 log_message(LOG_PROTOCOL, "%s\n", _("Mail sent successfully."));
444 ret = 0;
445 } else if (session->state == SESSION_EOF &&
446 SMTP_SESSION(session)->state == SMTP_QUIT) {
447 /* consider EOF right after QUIT successful */
448 log_warning(LOG_PROTOCOL, "%s\n", _("Connection closed by the remote host."));
449 ret = 0;
450 } else if (session->state == SESSION_ERROR ||
451 session->state == SESSION_EOF ||
452 session->state == SESSION_TIMEOUT ||
453 SMTP_SESSION(session)->state == SMTP_ERROR ||
454 SMTP_SESSION(session)->error_val != SM_OK)
455 ret = -1;
456 else if (send_dialog->cancelled == TRUE)
457 ret = -1;
458
459 if (ret == -1) {
460 manage_window_focus_in(send_dialog->dialog->window, NULL, NULL);
461 send_put_error(session);
462 manage_window_focus_out(send_dialog->dialog->window, NULL, NULL);
463 }
464
465 /* if we should close the connection, let's do it.
466 * Close it in case of error, too, as it helps reinitializing things
467 * easier.
468 */
469 if (!keep_session || ret != 0) {
470 if (session_is_connected(session))
471 smtp_quit(smtp_session);
472 while (session_is_connected(session) && !send_dialog->cancelled)
473 gtk_main_iteration();
474 session_destroy(session);
475 ac_prefs->session = NULL;
476 send_progress_dialog_destroy(send_dialog);
477 } else {
478 g_free(smtp_session->from);
479 g_free(smtp_session->send_data);
480 g_free(smtp_session->error_msg);
481 }
482 if (keep_session && ret == 0 && ac_prefs->session == NULL)
483 ac_prefs->session = SMTP_SESSION(session);
484
485
486 statusbar_pop_all();
487 statusbar_verbosity_set(FALSE);
488 return ret;
489 }
490
send_message_smtp(PrefsAccount * ac_prefs,GSList * to_list,FILE * fp)491 gint send_message_smtp(PrefsAccount *ac_prefs, GSList *to_list, FILE *fp)
492 {
493 return send_message_smtp_full(ac_prefs, to_list, fp, FALSE);
494 }
495
send_recv_message(Session * session,const gchar * msg,gpointer data)496 static gint send_recv_message(Session *session, const gchar *msg, gpointer data)
497 {
498 gchar buf[BUFFSIZE];
499 SMTPSession *smtp_session = SMTP_SESSION(session);
500 SendProgressDialog *dialog = (SendProgressDialog *)data;
501 gchar *state_str = NULL;
502
503 cm_return_val_if_fail(dialog != NULL, -1);
504
505 switch (smtp_session->state) {
506 case SMTP_READY:
507 return 0;
508 case SMTP_HELO:
509 g_snprintf(buf, sizeof(buf), _("Sending HELO..."));
510 state_str = _("Authenticating");
511 statusbar_print_all(_("Sending message..."));
512 break;
513 case SMTP_EHLO:
514 g_snprintf(buf, sizeof(buf), _("Sending EHLO..."));
515 state_str = _("Authenticating");
516 statusbar_print_all(_("Sending message..."));
517 break;
518 case SMTP_AUTH:
519 g_snprintf(buf, sizeof(buf), _("Authenticating..."));
520 state_str = _("Authenticating");
521 break;
522 case SMTP_FROM:
523 g_snprintf(buf, sizeof(buf), _("Sending MAIL FROM..."));
524 state_str = _("Sending");
525 break;
526 case SMTP_RCPT:
527 g_snprintf(buf, sizeof(buf), _("Sending RCPT TO..."));
528 state_str = _("Sending");
529 break;
530 case SMTP_DATA:
531 case SMTP_EOM:
532 g_snprintf(buf, sizeof(buf), _("Sending DATA..."));
533 state_str = _("Sending");
534 break;
535 case SMTP_QUIT:
536 g_snprintf(buf, sizeof(buf), _("Quitting..."));
537 state_str = _("Quitting");
538 break;
539 case SMTP_ERROR:
540 g_warning("send: error: %s", msg);
541 return 0;
542 default:
543 return 0;
544 }
545
546 progress_dialog_set_label(dialog->dialog, buf);
547 progress_dialog_list_set_status(dialog->dialog, 0, state_str);
548
549 return 0;
550 }
551
send_send_data_progressive(Session * session,guint cur_len,guint total_len,gpointer data)552 static gint send_send_data_progressive(Session *session, guint cur_len,
553 guint total_len, gpointer data)
554 {
555 gchar buf[BUFFSIZE];
556 SendProgressDialog *dialog = (SendProgressDialog *)data;
557 MainWindow *mainwin = mainwindow_get_mainwindow();
558
559 cm_return_val_if_fail(dialog != NULL, -1);
560
561 if (SMTP_SESSION(session)->state != SMTP_SEND_DATA &&
562 SMTP_SESSION(session)->state != SMTP_EOM)
563 return 0;
564
565 g_snprintf(buf, sizeof(buf), _("Sending message (%d / %d bytes)"),
566 cur_len, total_len);
567 progress_dialog_set_label(dialog->dialog, buf);
568 progress_dialog_set_fraction
569 (dialog->dialog, (total_len == 0) ? 0 : (gfloat)cur_len / (gfloat)total_len);
570
571 if (mainwin) {
572 if (!gtk_widget_get_visible(mainwin->progressbar))
573 gtk_widget_show(mainwin->progressbar);
574 gtk_progress_bar_set_fraction
575 (GTK_PROGRESS_BAR(mainwin->progressbar),
576 (total_len == 0) ? 0 : (gfloat)cur_len / (gfloat)total_len);
577 }
578
579 return 0;
580 }
581
send_send_data_finished(Session * session,guint len,gpointer data)582 static gint send_send_data_finished(Session *session, guint len, gpointer data)
583 {
584 SendProgressDialog *dialog = (SendProgressDialog *)data;
585 MainWindow *mainwin = mainwindow_get_mainwindow();
586
587 cm_return_val_if_fail(dialog != NULL, -1);
588
589 send_send_data_progressive(session, len, len, dialog);
590 if (mainwin) {
591 gtk_widget_hide(mainwin->progressbar);
592 gtk_progress_bar_set_fraction
593 (GTK_PROGRESS_BAR(mainwin->progressbar),(gfloat)0);
594 }
595
596 return 0;
597 }
598
send_progress_dialog_size_allocate_cb(GtkWidget * widget,GtkAllocation * allocation)599 static void send_progress_dialog_size_allocate_cb(GtkWidget *widget,
600 GtkAllocation *allocation)
601 {
602 cm_return_if_fail(allocation != NULL);
603
604 prefs_common.sendwin_width = allocation->width;
605 prefs_common.sendwin_height = allocation->height;
606 }
607
send_progress_dialog_create(void)608 static SendProgressDialog *send_progress_dialog_create(void)
609 {
610 SendProgressDialog *dialog;
611 ProgressDialog *progress;
612 static GdkGeometry geometry;
613
614 dialog = g_new0(SendProgressDialog, 1);
615
616 progress = progress_dialog_create();
617 gtk_window_set_title(GTK_WINDOW(progress->window),
618 _("Sending message"));
619 g_signal_connect(G_OBJECT(progress->showlog_btn), "clicked",
620 G_CALLBACK(send_showlog_button_cb), dialog);
621 g_signal_connect(G_OBJECT(progress->cancel_btn), "clicked",
622 G_CALLBACK(send_cancel_button_cb), dialog);
623 g_signal_connect(G_OBJECT(progress->window), "delete_event",
624 G_CALLBACK(gtk_true), NULL);
625 gtk_window_set_modal(GTK_WINDOW(progress->window), TRUE);
626 g_signal_connect(G_OBJECT(progress->window), "size_allocate",
627 G_CALLBACK(send_progress_dialog_size_allocate_cb), NULL);
628 manage_window_set_transient(GTK_WINDOW(progress->window));
629
630 progress_dialog_get_fraction(progress);
631
632 if (!geometry.min_height) {
633 geometry.min_width = 460;
634 geometry.min_height = 250;
635 }
636
637 gtk_window_set_geometry_hints(GTK_WINDOW(progress->window), NULL, &geometry,
638 GDK_HINT_MIN_SIZE);
639 gtk_widget_set_size_request(progress->window, prefs_common.sendwin_width,
640 prefs_common.sendwin_height);
641
642 if (!prefs_common.send_dialog_invisible) {
643 gtk_widget_show_now(progress->window);
644 }
645
646 dialog->dialog = progress;
647
648 return dialog;
649 }
650
send_progress_dialog_destroy(SendProgressDialog * dialog)651 static void send_progress_dialog_destroy(SendProgressDialog *dialog)
652 {
653 cm_return_if_fail(dialog != NULL);
654 if (!prefs_common.send_dialog_invisible) {
655 progress_dialog_destroy(dialog->dialog);
656 }
657 g_free(dialog);
658 send_dialog = NULL;
659 }
660
send_showlog_button_cb(GtkWidget * widget,gpointer data)661 static void send_showlog_button_cb(GtkWidget *widget, gpointer data)
662 {
663 MainWindow *mainwin = mainwindow_get_mainwindow();
664
665 log_window_show(mainwin->logwin);
666 }
667
send_cancel_button_cb(GtkWidget * widget,gpointer data)668 static void send_cancel_button_cb(GtkWidget *widget, gpointer data)
669 {
670 SendProgressDialog *dialog = (SendProgressDialog *)data;
671 statusbar_progress_all(0,0,0);
672
673 dialog->cancelled = TRUE;
674 }
675
send_put_error(Session * session)676 static void send_put_error(Session *session)
677 {
678 gchar *msg;
679 gchar *log_msg = NULL;
680 gchar *err_msg = NULL;
681
682 msg = SMTP_SESSION(session)->error_msg;
683
684 switch (SMTP_SESSION(session)->error_val) {
685 case SM_ERROR:
686 case SM_UNRECOVERABLE:
687 log_msg = _("Error occurred while sending the message.");
688 if (msg)
689 err_msg = g_strdup_printf
690 (_("Error occurred while sending the message:\n%s"),
691 msg);
692 else
693 err_msg = g_strdup(log_msg);
694 break;
695 case SM_AUTHFAIL:
696 log_msg = _("Authentication failed.");
697 if (msg)
698 err_msg = g_strdup_printf
699 (_("Authentication failed:\n%s"), msg);
700 else
701 err_msg = g_strdup(log_msg);
702 break;
703 default:
704 switch (session->state) {
705 case SESSION_ERROR:
706 log_msg =
707 _("Error occurred while sending the message.");
708 err_msg = g_strdup(log_msg);
709 break;
710 case SESSION_EOF:
711 log_msg = _("Connection closed by the remote host.");
712 err_msg = g_strdup(log_msg);
713 break;
714 case SESSION_TIMEOUT:
715 log_msg = _("Session timed out. You may be able to "
716 "recover by increasing the timeout value in "
717 "Preferences/Other/Miscellaneous.");
718 err_msg = g_strdup(log_msg);
719 break;
720 default:
721 break;
722 }
723 break;
724 }
725
726 if (err_msg) {
727 log_error(LOG_PROTOCOL, "%s\n", err_msg);
728 g_free(err_msg);
729 } else {
730 if (log_msg)
731 log_warning(LOG_PROTOCOL, "%s\n", log_msg);
732 }
733 }
734
735