src/send.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 <gtk/gtkmain.h>
  28 #include <gtk/gtksignal.h>
  29 #include <gtk/gtkwindow.h>
  30 #include <gtk/gtkclist.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <sys/time.h>
  34 #include <unistd.h>
  35
  36 #include "intl.h"
  37 #include "send.h"
  38 #include "socket.h"
  39 #include "ssl.h"
  40 #include "smtp.h"
  41 #include "esmtp.h"
  42 #include "prefs_common.h"
  43 #include "prefs_account.h"
  44 #include "account.h"
  45 #include "compose.h"
  46 #include "progressdialog.h"
  47 #include "inputdialog.h"
  48 #include "manage_window.h"
  49 #include "procmsg.h"
  50 #include "procheader.h"
  51 #include "utils.h"
  52 #include "gtkutils.h"
  53
  54 typedef struct _SendProgressDialog      SendProgressDialog;
  55
  56 struct _SendProgressDialog
  57 {
  58         ProgressDialog *dialog;
  59         GList *queue_list;
  60         gboolean cancelled;
  61 };
  62
  63 #if USE_SSL
  64 static SockInfo *send_smtp_open (const gchar *server, gushort port,
  65                                  const gchar *domain, gboolean use_smtp_auth,
  66                                  SSLSMTPType ssl_type);
  67 #else
  68 static SockInfo *send_smtp_open (const gchar *server, gushort port,
  69                                  const gchar *domain, gboolean use_smtp_auth);
  70 #endif
  71
  72 static gint send_message_data   (SendProgressDialog *dialog, SockInfo *sock,
  73                                  FILE *fp, gint size);
  74
  75 static SendProgressDialog *send_progress_dialog_create(void);
  76 static void send_progress_dialog_destroy(SendProgressDialog *dialog);
  77 static void send_cancel(GtkWidget *widget, gpointer data);
  78
  79
  80 gint send_message(const gchar *file, PrefsAccount *ac_prefs, GSList *to_list)
  81 {
  82         FILE *fp;
  83         gint val;
  84
  85         g_return_val_if_fail(file != NULL, -1);
  86         g_return_val_if_fail(ac_prefs != NULL, -1);
  87         g_return_val_if_fail(to_list != NULL, -1);
  88
  89         if ((fp = fopen(file, "r")) == NULL) {
  90                 FILE_OP_ERROR(file, "fopen");
  91                 return -1;
  92         }
  93
  94         if (prefs_common.use_extsend && prefs_common.extsend_cmd) {
  95                 val = send_message_local(prefs_common.extsend_cmd, fp);
  96                 fclose(fp);
  97                 return val;
  98         }
  99
 100         val = send_message_smtp(ac_prefs, to_list, fp);
 101
 102         fclose(fp);
 103         return val;
 104 }
 105
 106 enum
 107 {
 108         Q_SENDER     = 0,
 109         Q_SMTPSERVER = 1,
 110         Q_RECIPIENTS = 2,
 111         Q_ACCOUNT_ID = 3
 112 };
 113
 114 gint send_message_queue(const gchar *file)
 115 {
 116         static HeaderEntry qentry[] = {{"S:",   NULL, FALSE},
 117                                        {"SSV:", NULL, FALSE},
 118                                        {"R:",   NULL, FALSE},
 119                                        {"AID:", NULL, FALSE},
 120                                        {NULL,   NULL, FALSE}};
 121         FILE *fp;
 122         gint val;
 123         gchar *from = NULL;
 124         gchar *server = NULL;
 125         GSList *to_list = NULL;
 126         gchar buf[BUFFSIZE];
 127         gint hnum;
 128         PrefsAccount *ac = NULL;
 129
 130         g_return_val_if_fail(file != NULL, -1);
 131
 132         if ((fp = fopen(file, "r")) == NULL) {
 133                 FILE_OP_ERROR(file, "fopen");
 134                 return -1;
 135         }
 136
 137         while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry))
 138                != -1) {
 139                 gchar *p = buf + strlen(qentry[hnum].name);
 140
 141                 switch (hnum) {
 142                 case Q_SENDER:
 143                         if (!from) from = g_strdup(p);
 144                         break;
 145                 case Q_SMTPSERVER:
 146                         if (!server) server = g_strdup(p);
 147                         break;
 148                 case Q_RECIPIENTS:
 149                         to_list = address_list_append(to_list, p);
 150                         break;
 151                 case Q_ACCOUNT_ID:
 152                         ac = account_find_from_id(atoi(p));
 153                         break;
 154                 default:
 155                 }
 156         }
 157
 158         if (!to_list || !from) {
 159                 g_warning(_("Queued message header is broken.\n"));
 160                 val = -1;
 161         } else if (prefs_common.use_extsend && prefs_common.extsend_cmd) {
 162                 val = send_message_local(prefs_common.extsend_cmd, fp);
 163         } else {
 164                 if (!ac) {
 165                         ac = account_find_from_smtp_server(from, server);
 166                         if (!ac) {
 167                                 g_warning(_("Account not found. "
 168                                             "Using current account...\n"));
 169                                 ac = cur_account;
 170                         }
 171                 }
 172
 173                 if (ac)
 174                         val = send_message_smtp(ac, to_list, fp);
 175                 else {
 176                         PrefsAccount tmp_ac;
 177
 178                         g_warning(_("Account not found.\n"));
 179
 180                         memset(&tmp_ac, 0, sizeof(PrefsAccount));
 181                         tmp_ac.address = from;
 182                         tmp_ac.smtp_server = server;
 183                         tmp_ac.smtpport = SMTP_PORT;
 184                         val = send_message_smtp(&tmp_ac, to_list, fp);
 185                 }
 186         }
 187
 188         slist_free_strings(to_list);
 189         g_slist_free(to_list);
 190         g_free(from);
 191         g_free(server);
 192         fclose(fp);
 193
 194         return val;
 195 }
 196
 197 gint send_message_local(const gchar *command, FILE *fp)
 198 {
 199         FILE *pipefp;
 200         gchar buf[BUFFSIZE];
 201
 202         g_return_val_if_fail(command != NULL, -1);
 203         g_return_val_if_fail(fp != NULL, -1);
 204
 205         pipefp = popen(command, "w");
 206         if (!pipefp) {
 207                 g_warning(_("Can't execute external command: %s\n"), command);
 208                 return -1;
 209         }
 210
 211         while (fgets(buf, sizeof(buf), fp) != NULL) {
 212                 strretchomp(buf);
 213                 /* escape when a dot appears on the top */
 214                 if (buf[0] == '.')
 215                         fputc('.', pipefp);
 216                 fputs(buf, pipefp);
 217                 fputc('\n', pipefp);
 218         }
 219
 220         pclose(pipefp);
 221
 222         return 0;
 223 }
 224
 225 #define EXIT_IF_CANCELLED() \
 226 { \
 227         if (dialog->cancelled) { \
 228                 sock_close(smtp_sock); \
 229                 send_progress_dialog_destroy(dialog); \
 230                 return -1; \
 231         } \
 232 }
 233
 234 #define SEND_EXIT_IF_ERROR(f, s) \
 235 { \
 236         EXIT_IF_CANCELLED(); \
 237         if (!(f)) { \
 238                 log_warning("Error occurred while %s\n", s); \
 239                 sock_close(smtp_sock); \
 240                 send_progress_dialog_destroy(dialog); \
 241                 return -1; \
 242         } \
 243 }
 244
 245 #define SEND_EXIT_IF_NOTOK(f, s) \
 246 { \
 247         gint ok; \
 248  \
 249         EXIT_IF_CANCELLED(); \
 250         if ((ok = (f)) != SM_OK) { \
 251                 log_warning("Error occurred while %s\n", s); \
 252                 if (ok == SM_AUTHFAIL) { \
 253                         log_warning("SMTP AUTH failed\n"); \
 254                         if (ac_prefs->tmp_pass) { \
 255                                 g_free(ac_prefs->tmp_pass); \
 256                                 ac_prefs->tmp_pass = NULL; \
 257                         } \
 258                 } \
 259                 if (smtp_quit(smtp_sock) != SM_OK) \
 260                         log_warning("Error occurred while sending QUIT\n"); \
 261                 sock_close(smtp_sock); \
 262                 send_progress_dialog_destroy(dialog); \
 263                 return -1; \
 264         } \
 265 }
 266
 267 gint send_message_smtp(PrefsAccount *ac_prefs, GSList *to_list,
 268                               FILE *fp)
 269 {
 270         SockInfo *smtp_sock = NULL;
 271         SendProgressDialog *dialog;
 272         GtkCList *clist;
 273         const gchar *text[3];
 274         gchar buf[BUFFSIZE];
 275         gushort port;
 276         gchar *domain;
 277         gchar *user = NULL;
 278         gchar *pass = NULL;
 279         GSList *cur;
 280         gint size;
 281
 282         g_return_val_if_fail(ac_prefs != NULL, -1);
 283         g_return_val_if_fail(ac_prefs->address != NULL, -1);
 284         g_return_val_if_fail(ac_prefs->smtp_server != NULL, -1);
 285         g_return_val_if_fail(to_list != NULL, -1);
 286         g_return_val_if_fail(fp != NULL, -1);
 287
 288         size = get_left_file_size(fp);
 289         if (size < 0) return -1;
 290
 291 #if USE_SSL
 292         port = ac_prefs->set_smtpport ? ac_prefs->smtpport :
 293                 ac_prefs->ssl_smtp == SSL_SMTP_TUNNEL ? SSMTP_PORT : SMTP_PORT;
 294 #else
 295         port = ac_prefs->set_smtpport ? ac_prefs->smtpport : SMTP_PORT;
 296 #endif
 297         domain = ac_prefs->set_domain ? ac_prefs->domain : NULL;
 298
 299         if (ac_prefs->use_smtp_auth) {
 300                 if (ac_prefs->smtp_userid) {
 301                         user = ac_prefs->smtp_userid;
 302                         if(ac_prefs->smtp_passwd)
 303                                 pass = ac_prefs->smtp_passwd;
 304                         else if (ac_prefs->tmp_pass)
 305                                 pass = ac_prefs->tmp_pass;
 306                         else {
 307                                 pass = input_dialog_query_password
 308                                         (ac_prefs->smtp_server, ac_prefs->smtp_userid);
 309                                 if (!pass) pass = g_strdup("");
 310                                 ac_prefs->tmp_pass = pass;
 311                         }
 312                 } else {
 313                         user = ac_prefs->userid;
 314                         if (ac_prefs->passwd) {
 315                                 pass = ac_prefs->passwd;
 316                         } else if (ac_prefs->tmp_pass)
 317                                 pass = ac_prefs->tmp_pass;
 318                         else {
 319                                 pass = input_dialog_query_password
 320                                         (ac_prefs->smtp_server, ac_prefs->userid);
 321                                 if (!pass) pass = g_strdup("");
 322                                 ac_prefs->tmp_pass = pass;
 323                         }
 324                 }
 325         }
 326
 327         dialog = send_progress_dialog_create();
 328
 329         text[0] = NULL;
 330         text[1] = ac_prefs->smtp_server;
 331         text[2] = _("Standby");
 332         clist = GTK_CLIST(dialog->dialog->clist);
 333         gtk_clist_append(clist, (gchar **)text);
 334
 335         g_snprintf(buf, sizeof(buf), _("Connecting to SMTP server: %s ..."),
 336                    ac_prefs->smtp_server);
 337         log_message("%s\n", buf);
 338         progress_dialog_set_label(dialog->dialog, buf);
 339         gtk_clist_set_text(clist, 0, 2, _("Connecting"));
 340         GTK_EVENTS_FLUSH();
 341
 342 #if USE_SSL
 343         SEND_EXIT_IF_ERROR((smtp_sock = send_smtp_open
 344                                 (ac_prefs->smtp_server, port, domain,
 345                                  ac_prefs->use_smtp_auth, ac_prefs->ssl_smtp)),
 346                            "connecting to server");
 347 #else
 348         SEND_EXIT_IF_ERROR((smtp_sock = send_smtp_open
 349                                 (ac_prefs->smtp_server, port, domain,
 350                                  ac_prefs->use_smtp_auth)),
 351                            "connecting to server");
 352 #endif
 353
 354         progress_dialog_set_label(dialog->dialog, _("Sending MAIL FROM..."));
 355         gtk_clist_set_text(clist, 0, 2, _("Sending"));
 356         GTK_EVENTS_FLUSH();
 357
 358         SEND_EXIT_IF_NOTOK
 359                 (smtp_from(smtp_sock, ac_prefs->address, user,
 360                            pass, ac_prefs->use_smtp_auth),
 361                  "sending MAIL FROM");
 362
 363         progress_dialog_set_label(dialog->dialog, _("Sending RCPT TO..."));
 364         GTK_EVENTS_FLUSH();
 365
 366         for (cur = to_list; cur != NULL; cur = cur->next)
 367                 SEND_EXIT_IF_NOTOK(smtp_rcpt(smtp_sock, (gchar *)cur->data),
 368                                    "sending RCPT TO");
 369
 370         progress_dialog_set_label(dialog->dialog, _("Sending DATA..."));
 371         GTK_EVENTS_FLUSH();
 372
 373         SEND_EXIT_IF_NOTOK(smtp_data(smtp_sock), "sending DATA");
 374
 375         /* send main part */
 376         SEND_EXIT_IF_ERROR(send_message_data(dialog, smtp_sock, fp, size) == 0,
 377                            "sending data");
 378
 379         progress_dialog_set_label(dialog->dialog, _("Quitting..."));
 380         GTK_EVENTS_FLUSH();
 381
 382         SEND_EXIT_IF_NOTOK(smtp_eom(smtp_sock), "terminating data");
 383         SEND_EXIT_IF_NOTOK(smtp_quit(smtp_sock), "sending QUIT");
 384
 385         sock_close(smtp_sock);
 386         send_progress_dialog_destroy(dialog);
 387
 388         return 0;
 389 }
 390
 391 #undef EXIT_IF_CANCELLED
 392 #undef SEND_EXIT_IF_ERROR
 393 #undef SEND_EXIT_IF_NOTOK
 394
 395 #define EXIT_IF_CANCELLED() \
 396 { \
 397         if (dialog->cancelled) return -1; \
 398 }
 399
 400 #define SEND_EXIT_IF_ERROR(f) \
 401 { \
 402         EXIT_IF_CANCELLED(); \
 403         if ((f) <= 0) return -1; \
 404 }
 405
 406 #define SEND_DIALOG_UPDATE() \
 407 { \
 408         gettimeofday(&tv_cur, NULL); \
 409         if (tv_cur.tv_sec - tv_prev.tv_sec > 0 || \
 410             tv_cur.tv_usec - tv_prev.tv_usec > UI_REFRESH_INTERVAL) { \
 411                 g_snprintf(str, sizeof(str), \
 412                            _("Sending message (%d / %d bytes)"), \
 413                            bytes, size); \
 414                 progress_dialog_set_label(dialog->dialog, str); \
 415                 progress_dialog_set_percentage \
 416                         (dialog->dialog, (gfloat)bytes / (gfloat)size); \
 417                 GTK_EVENTS_FLUSH(); \
 418                 gettimeofday(&tv_prev, NULL); \
 419         } \
 420 }
 421
 422 static gint send_message_data(SendProgressDialog *dialog, SockInfo *sock,
 423                               FILE *fp, gint size)
 424 {
 425         gchar buf[BUFFSIZE];
 426         gchar str[BUFFSIZE];
 427         gint bytes = 0;
 428         struct timeval tv_prev, tv_cur;
 429
 430         gettimeofday(&tv_prev, NULL);
 431
 432         /* output header part */
 433         while (fgets(buf, sizeof(buf), fp) != NULL) {
 434                 bytes += strlen(buf);
 435                 strretchomp(buf);
 436
 437                 SEND_DIALOG_UPDATE();
 438
 439                 if (!g_strncasecmp(buf, "Bcc:", 4)) {
 440                         gint next;
 441
 442                         for (;;) {
 443                                 next = fgetc(fp);
 444                                 if (next == EOF)
 445                                         break;
 446                                 else if (next != ' ' && next != '\t') {
 447                                         ungetc(next, fp);
 448                                         break;
 449                                 }
 450                                 if (fgets(buf, sizeof(buf), fp) == NULL)
 451                                         break;
 452                                 else
 453                                         bytes += strlen(buf);
 454                         }
 455                 } else {
 456                         SEND_EXIT_IF_ERROR(sock_puts(sock, buf));
 457                         if (buf[0] == '\0')
 458                                 break;
 459                 }
 460         }
 461
 462         /* output body part */
 463         while (fgets(buf, sizeof(buf), fp) != NULL) {
 464                 bytes += strlen(buf);
 465                 strretchomp(buf);
 466
 467                 SEND_DIALOG_UPDATE();
 468
 469                 /* escape when a dot appears on the top */
 470                 if (buf[0] == '.')
 471                         SEND_EXIT_IF_ERROR(sock_write(sock, ".", 1));
 472
 473                 SEND_EXIT_IF_ERROR(sock_puts(sock, buf));
 474         }
 475
 476         g_snprintf(str, sizeof(str), _("Sending message (%d / %d bytes)"),
 477                    bytes, size);
 478         progress_dialog_set_label(dialog->dialog, str);
 479         progress_dialog_set_percentage
 480                 (dialog->dialog, (gfloat)bytes / (gfloat)size);
 481         GTK_EVENTS_FLUSH();
 482
 483         return 0;
 484 }
 485
 486 #undef EXIT_IF_CANCELLED
 487 #undef SEND_EXIT_IF_ERROR
 488 #undef SEND_DIALOG_UPDATE
 489
 490 #if USE_SSL
 491 static SockInfo *send_smtp_open(const gchar *server, gushort port,
 492                                 const gchar *domain, gboolean use_smtp_auth,
 493                                 SSLSMTPType ssl_type)
 494 #else
 495 static SockInfo *send_smtp_open(const gchar *server, gushort port,
 496                                 const gchar *domain, gboolean use_smtp_auth)
 497 #endif
 498 {
 499         SockInfo *sock;
 500         gint val;
 501
 502         g_return_val_if_fail(server != NULL, NULL);
 503
 504         if ((sock = sock_connect(server, port)) == NULL) {
 505                 log_warning(_("Can't connect to SMTP server: %s:%d\n"),
 506                             server, port);
 507                 return NULL;
 508         }
 509
 510 #if USE_SSL
 511         if (ssl_type == SSL_SMTP_TUNNEL && !ssl_init_socket(sock)) {
 512                 log_warning(_("SSL connection failed"));
 513                 sock_close(sock);
 514                 return NULL;
 515         }
 516 #endif
 517
 518         if (smtp_ok(sock) != SM_OK) {
 519                 log_warning(_("Error occurred while connecting to %s:%d\n"),
 520                             server, port);
 521                 sock_close(sock);
 522                 return NULL;
 523         }
 524
 525 #if USE_SSL
 526         val = smtp_helo(sock, domain ? domain : get_domain_name(),
 527                         use_smtp_auth || ssl_type == SSL_SMTP_STARTTLS);
 528 #else
 529         val = smtp_helo(sock, domain ? domain : get_domain_name(),
 530                         use_smtp_auth);
 531 #endif
 532
 533         if (val != SM_OK) {
 534                 log_warning(_("Error occurred while sending HELO\n"));
 535                 sock_close(sock);
 536                 return NULL;
 537         }
 538
 539 #if USE_SSL
 540         if (ssl_type == SSL_SMTP_STARTTLS) {
 541                 val = esmtp_starttls(sock);
 542                 if (val != SM_OK) {
 543                         log_warning(_("Error occurred while sending STARTTLS\n"));
 544                         sock_close(sock);
 545                         return NULL;
 546                 }
 547                 if (!ssl_init_socket_with_method(sock, SSL_METHOD_TLSv1)) {
 548                         sock_close(sock);
 549                         return NULL;
 550                 }
 551                 val = esmtp_ehlo(sock, domain ? domain : get_domain_name());
 552                 if (val != SM_OK) {
 553                         log_warning(_("Error occurred while sending EHLO\n"));
 554                         sock_close(sock);
 555                         return NULL;
 556                 }
 557         }
 558 #endif
 559
 560         return sock;
 561 }
 562
 563
 564 static SendProgressDialog *send_progress_dialog_create(void)
 565 {
 566         SendProgressDialog *dialog;
 567         ProgressDialog *progress;
 568
 569         dialog = g_new0(SendProgressDialog, 1);
 570
 571         progress = progress_dialog_create();
 572         gtk_window_set_title(GTK_WINDOW(progress->window),
 573                              _("Sending message"));
 574         gtk_signal_connect(GTK_OBJECT(progress->cancel_btn), "clicked",
 575                            GTK_SIGNAL_FUNC(send_cancel), dialog);
 576         gtk_signal_connect(GTK_OBJECT(progress->window), "delete_event",
 577                            GTK_SIGNAL_FUNC(gtk_true), NULL);
 578         gtk_window_set_modal(GTK_WINDOW(progress->window), TRUE);
 579         manage_window_set_transient(GTK_WINDOW(progress->window));
 580
 581         progress_dialog_set_value(progress, 0.0);
 582
 583         gtk_widget_show_now(progress->window);
 584
 585         dialog->dialog = progress;
 586         dialog->queue_list = NULL;
 587         dialog->cancelled = FALSE;
 588
 589         return dialog;
 590 }
 591
 592 static void send_progress_dialog_destroy(SendProgressDialog *dialog)
 593 {
 594         g_return_if_fail(dialog != NULL);
 595
 596         progress_dialog_destroy(dialog->dialog);
 597         g_free(dialog);
 598 }
 599
 600 static void send_cancel(GtkWidget *widget, gpointer data)
 601 {
 602         SendProgressDialog *dialog = data;
 603
 604         dialog->cancelled = TRUE;
 605 }