X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=sendlib.c;h=8891280168f55ca88348e2cb1ca32860118d4921;hp=042ca3ac595807fbcca1fa45e29d6af6a6f8cb40;hb=5ef16452ce43a12e467e7004a6a240aefb87a774;hpb=7b392ef7b50798f9eb3e7c869e634c5fef0092d1 diff --git a/sendlib.c b/sendlib.c index 042ca3a..8891280 100644 --- a/sendlib.c +++ b/sendlib.c @@ -10,28 +10,29 @@ #include #include -#include +#ifdef USE_LIBESMTP +#include +#include +#endif + +#include #include #include #include +#include #include #include -#include - #include "mutt.h" #include "handler.h" +#include "crypt.h" #include "recvattach.h" #include "copy.h" #include "pager.h" #include "charset.h" #include "mutt_idna.h" -#ifdef USE_LIBESMTP -# include "mutt_libesmtp.h" -#endif /* USE_LIBESMTP */ - #ifdef USE_NNTP #include #endif @@ -42,6 +43,383 @@ #define EX_OK 0 #endif +#ifdef USE_LIBESMTP +static char authpass[STRING] = ""; + +#define FAIL() \ + do { \ + ret = -1; \ + goto Done; \ + } while (0) +#define MSGFAIL(msg) \ + do { \ + mutt_error("%s", msg); \ + FAIL(); \ + } while (0) +#define LIBCFAIL(msg) \ + do { \ + mutt_error("%s: %s", msg, strerror(errno)); \ + FAIL(); \ + } while (0) +#define SMTPFAIL(msg) \ + do { \ + _send_smtp_perror(msg); \ + FAIL(); \ + } while (0) +#define extna(msg) { mutt_error (_("SMTP Extension '%s' not supported by MTA."), \ + msg); sleep (1); } + +/* + * _send_smtp_ensure_init + * Make sure the libESMTP support in mutt is initialized at some time. + */ +static void _send_smtp_ensure_init () +{ + static int libesmtp_init = 0; + + if (!libesmtp_init) { + if (SmtpAuthUser) + auth_client_init (); + libesmtp_init = 1; + } +} + +/* + * _send_smtp_perror + * Prints 'msg', a colon, and then a string representation of the + * libesmtp errno as a mutt error. + */ +static void _send_smtp_perror (const char *msg) +{ + char buf[512]; + + mutt_error ("%s: %s", msg, + smtp_strerror (smtp_errno (), buf, sizeof (buf))); +} + +/* + * _send_smtp_add_recipients + * Adds every address in 'addr' as a recipient to the smtp message + * 'message'. Note that this does not mean that they will necessarily + * show up in the mail headers (e.g., when bcc'ing). Returns 0 upon + * success, -1 upon failure (and prints an error message). + * + * Very similar to sendlib.c::add_args + */ +static int +_send_smtp_add_recipients (smtp_message_t message, address_t * addr) +{ + int ret = 0; + + for (; addr; addr = addr->next) { + /* weed out group mailboxes, since those are for display only */ + if (addr->mailbox && !addr->group) { + if (!smtp_add_recipient (message, addr->mailbox)) + SMTPFAIL ("smtp_add_recipient"); + } + } + +Done: + return ret; +} + +static int +_send_smtp_auth_interact (auth_client_request_t request, + char **result, int fields, + void *arg __attribute__ ((unused))) +{ + int i; + + for (i = 0; i < fields; i++) { + if (request[i].flags & AUTH_USER) { + result[i] = SmtpAuthUser; + } else if (request[i].flags & AUTH_PASS) { + if (SmtpAuthPass) { + result[i] = SmtpAuthPass; + } else { + if (authpass[0] == '\0') { + char prompt[STRING]; + + snprintf(prompt, sizeof(prompt), "%s%s: ", request[i].prompt, + request[i].flags & AUTH_CLEARTEXT ? " (not encrypted)" : + ""); + mutt_get_field_unbuffered(prompt, authpass, sizeof(authpass), + M_PASS); + } + result[i] = authpass; + } + } + } + + return 1; +} + +#define BUFLEN 8192 + +static const char * +_send_smtp_messagefp_cb(void **buf, int *len, void *arg) +{ + int octets; + + if (*buf == NULL) + *buf = xmalloc(BUFLEN); + + if (len == NULL) { + rewind ((FILE *) arg); + return NULL; + } + + if (fgets (*buf, BUFLEN - 2, (FILE *) arg) == NULL) { + octets = 0; + } + else { + char *p = strchr (*buf, '\0'); + + if (p[-1] == '\n' && p[-2] != '\r') { + m_strcpy(p - 1, (char *) *buf + BUFLEN - p + 1, "\r\n"); + p++; + } + octets = p - (char *) *buf; + } + + *len = octets; + return *buf; +} + +static int handle_invalid_peer_certificate (long vfy_result) { +#if defined (HAVE_GNUTLS_OPENSSL_H) + mutt_error (_("Error verifying certificate: %s"), + NONULL (X509_verify_cert_error_string (vfy_result))); +#else + mutt_error (_("Error verifying certificate. Error Code: %lu"), vfy_result); +#endif + sleep(2); + return 1; /* Accept the problem */ +} + +static void event_cb (smtp_session_t session __attribute__ ((unused)), + int event_no, void *arg,...) +{ + va_list alist; + int *ok; + + va_start(alist, arg); + switch(event_no) { + case SMTP_EV_CONNECT: + case SMTP_EV_MAILSTATUS: + case SMTP_EV_RCPTSTATUS: + case SMTP_EV_MESSAGEDATA: + case SMTP_EV_MESSAGESENT: + case SMTP_EV_DISCONNECT: break; + case SMTP_EV_WEAK_CIPHER: { + int bits; + bits = va_arg(alist, long); ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_WEAK_CIPHER, bits=%d - accepted."), bits); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_STARTTLS_OK: + mutt_message (_("Using TLS")); + sleep(1); + break; + case SMTP_EV_INVALID_PEER_CERTIFICATE: { + long vfy_result; + vfy_result = va_arg(alist, long); ok = va_arg(alist, int*); + *ok = handle_invalid_peer_certificate(vfy_result); + sleep(1); + break; + } + case SMTP_EV_NO_PEER_CERTIFICATE: { + ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_NO_PEER_CERTIFICATE - accepted.")); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_WRONG_PEER_CERTIFICATE: { + ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_WRONG_PEER_CERTIFICATE - accepted.")); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_NO_CLIENT_CERTIFICATE: { + ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_NO_CLIENT_CERTIFICATE - accepted.")); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_EXTNA_DSN: + extna ("DSN"); + break; + case SMTP_EV_EXTNA_STARTTLS: + extna ("StartTLS"); + break; + case SMTP_EV_EXTNA_8BITMIME: + extna ("8BITMIME"); + break; + default: + mutt_message(_("Got unhandled event ID = %d - ignored."), event_no); + sleep(1); + } + va_end(alist); +} + +static void do_dsn_notify (smtp_message_t message, const char* from) { + int flags = Notify_NOTSET; + smtp_recipient_t self = NULL; + + if (m_strisempty(MTransport.dsn_notify) || !message || m_strisempty(from) || + strstr (MTransport.dsn_notify, "never") != NULL) + return; + + if (strstr (MTransport.dsn_notify, "failure") != NULL) + flags |= Notify_FAILURE; + if (strstr (MTransport.dsn_notify, "delay") != NULL) + flags |= Notify_DELAY; + if (strstr (MTransport.dsn_notify, "success") != NULL) + flags |= Notify_SUCCESS; + + if (flags != Notify_NOTSET) { + if (!(self = smtp_add_recipient (message, from))) + return; + smtp_dsn_set_notify (self, flags); + } +} + +static void do_dsn_ret (smtp_message_t message) { + if (m_strisempty(MTransport.dsn_return) || !message) + return; + if (ascii_strncasecmp (MTransport.dsn_return, "hdrs", 4) == 0) + smtp_dsn_set_ret (message, Ret_HDRS); + else if (ascii_strncasecmp (MTransport.dsn_return, "full", 4) == 0) + smtp_dsn_set_ret (message, Ret_FULL); +} + +int send_smtp_check_usetls (const char* option, unsigned long p, + char* errbuf, ssize_t errlen) { + char* val = (char*) p; + if (m_strisempty(val)) + return (1); + if (m_strncmp(val, "enabled", 7) != 0 && + m_strncmp(val, "required", 8) != 0) { + if (errbuf) + snprintf (errbuf, errlen, _("'%s' is invalid for %s"), val, option); + return (0); + } + return (1); +} + +/* + * send_smtp_invoke + * Sends a mail message to the provided recipients using libesmtp. + * Returns 0 upon success, -1 upon failure (and prints an error + * message). + */ +static int +send_smtp_invoke(address_t *from, address_t *to, address_t *cc, + address_t *bcc, const char *msg, int eightbit) +{ /* message contains 8bit chars */ + int ret = 0; /* return value, default = success */ + smtp_session_t session; + smtp_message_t message; + char *hostportstr = NULL; + size_t hostportlen; + FILE *fp = NULL; + auth_context_t authctx = NULL; + const smtp_status_t *status; + char* envfrom = from->mailbox; + + _send_smtp_ensure_init (); + + if ((session = smtp_create_session ()) == NULL) + SMTPFAIL ("smtp_create_session"); + +#ifdef HAVE_GNUTLS_OPENSSL_H + if (SmtpUseTLS != NULL && ascii_strncasecmp("enabled", SmtpUseTLS, 7) == 0) { + smtp_starttls_enable(session, Starttls_ENABLED); + } else if (SmtpUseTLS != NULL && ascii_strncasecmp("required", SmtpUseTLS, 8) == 0) { + smtp_starttls_enable(session, Starttls_REQUIRED); + } +#endif + + /* Create hostname:port string and tell libesmtp */ + /* len = SmtpHost len + colon + max port (65536 => 5 chars) + terminator */ + hostportlen = m_strlen(SmtpHost) + 7; + hostportstr = p_new(char, hostportlen); + snprintf (hostportstr, hostportlen, "%s:%d", SmtpHost, SmtpPort); + if (!smtp_set_server (session, hostportstr)) + SMTPFAIL ("smtp_set_server"); + + if (SmtpAuthUser) { + if ((authctx = auth_create_context ()) == NULL) + MSGFAIL ("auth_create_context failed"); + auth_set_mechanism_flags (authctx, AUTH_PLUGIN_PLAIN, 0); + auth_set_interact_cb (authctx, _send_smtp_auth_interact, NULL); + + if (!smtp_auth_set_context (session, authctx)) + SMTPFAIL ("smtp_auth_set_context"); + } + +#ifdef HAVE_GNUTLS_OPENSSL_H + smtp_starttls_set_ctx (session, NULL); +#endif + smtp_set_eventcb (session, event_cb, NULL); + + if ((message = smtp_add_message (session)) == NULL) + SMTPFAIL ("smtp_add_message"); + + /* Initialize envelope sender */ + if (MTransport.use_envelope_from && MTransport.envelope_from_address) + envfrom = MTransport.envelope_from_address->mailbox; + if (!smtp_set_reverse_path (message, envfrom)) + SMTPFAIL ("smtp_set_reverse_path"); + + /* set up DSN for message */ + do_dsn_notify (message, envfrom); + do_dsn_ret (message); + + /* set up 8bitmime flag */ + if (eightbit && MTransport.use_8bitmime) + smtp_8bitmime_set_body (message, E8bitmime_8BITMIME); + + if ((fp = fopen (msg, "r")) == NULL) + LIBCFAIL ("fopen"); + if (!smtp_set_messagecb (message, _send_smtp_messagefp_cb, fp)) + SMTPFAIL ("smtp_set_messagecb"); + if (_send_smtp_add_recipients (message, to)) + FAIL (); + if (_send_smtp_add_recipients (message, cc)) + FAIL (); + if (_send_smtp_add_recipients (message, bcc)) + FAIL (); + if (!smtp_start_session (session)) + SMTPFAIL ("smtp_start_session"); + + status = smtp_message_transfer_status (message); + if (status->code < 200 || status->code > 299) { + char buf[256]; + + snprintf (buf, sizeof (buf), "SMTP error while sending: %d %s", + status->code, status->text); + MSGFAIL (buf); + } + +Done: + m_fclose(&fp); + if (hostportstr != NULL) + p_delete(&hostportstr); + if (session != NULL) + smtp_destroy_session (session); + if (authctx != NULL) + auth_destroy_context (authctx); + + /* Forget user-entered SMTP AUTH password if send fails */ + if (ret != 0) + authpass[0] = '\0'; + + return ret; +} +#endif + static void transform_to_7bit (BODY * a, FILE * fpin); static void encode_quoted (fgetconv_t * fc, FILE * fout, int istext) @@ -231,7 +609,8 @@ static void encode_base64 (fgetconv_t * fc, FILE * fout, int istext) fputc ('\n', fout); } -static void encode_8bit (fgetconv_t * fc, FILE * fout, int istext) +static void encode_8bit (fgetconv_t * fc, FILE * fout, + int istext __attribute__ ((unused))) { int ch; @@ -338,8 +717,8 @@ int mutt_write_mime_header (BODY * a, FILE * f) int mutt_write_mime_body (BODY * a, FILE * f) { const char *p; - char boundary[SHORT_STRING]; - char send_charset[SHORT_STRING]; + char boundary[STRING]; + char send_charset[STRING]; FILE *fpin; BODY *t; fgetconv_t *fc; @@ -395,7 +774,7 @@ int mutt_write_mime_body (BODY * a, FILE * f) #undef write_as_text_part fgetconv_close (&fc); - fclose (fpin); + m_fclose(&fpin); return (ferror (f) ? -1 : 0); } @@ -537,7 +916,6 @@ static ssize_t convert_file_to (FILE * file, const char *fromcode, int ncodes, const char **tocodes, int *tocode, CONTENT * info) { -#ifdef HAVE_ICONV iconv_t cd1, *cd; char bufi[256], bufu[512], bufo[4 * sizeof (bufi)]; const char *ib, *ub; @@ -645,9 +1023,6 @@ static ssize_t convert_file_to (FILE * file, const char *fromcode, p_delete(&states); return ret; -#else - return -1; -#endif /* !HAVE_ICONV */ } /* @@ -765,10 +1140,10 @@ CONTENT *mutt_get_content_info (const char *fname, BODY * b) if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset)) { const char *chs = parameter_getval(b->parameter, "charset"); - char *fchs = b->use_disp ? ((FileCharset && *FileCharset) ? - FileCharset : Charset) : Charset; - if (Charset && (chs || SendCharset) && - convert_file_from_to (fp, fchs, chs ? chs : SendCharset, + char *fchs = b->use_disp && !m_strisempty(mod_cset.file_charset) + ? FileCharset : mod_cset.charset; + if (mod_cset.charset && (chs || mod_cset.send_charset) && + convert_file_from_to (fp, fchs, chs ? chs : mod_cset.send_charset, &fromcode, &tocode, info) != -1) { if (!chs) { charset_canonicalize (chsbuf, sizeof (chsbuf), tocode); @@ -776,7 +1151,7 @@ CONTENT *mutt_get_content_info (const char *fname, BODY * b) } b->file_charset = fromcode; p_delete(&tocode); - safe_fclose (&fp); + m_fclose(&fp); return info; } } @@ -786,12 +1161,13 @@ CONTENT *mutt_get_content_info (const char *fname, BODY * b) update_content_info (info, &state, buffer, r); update_content_info (info, &state, 0, 0); - safe_fclose (&fp); + m_fclose(&fp); if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset)) parameter_setval(&b->parameter, "charset", (!info->hibin ? "us-ascii" - : Charset && !charset_is_us_ascii(Charset) ? Charset : "unknown-8bit")); + : mod_cset.charset && !charset_is_us_ascii(mod_cset.charset) + ? mod_cset.charset : "unknown-8bit")); return info; } @@ -827,7 +1203,7 @@ int mutt_lookup_mime_type (BODY * att, const char *path) */ switch (count) { case 0: - snprintf (buf, sizeof (buf), "%s/.mime.types", NONULL (Homedir)); + snprintf(buf, sizeof (buf), "%s/.mime.types", NONULL(mod_core.homedir)); break; case 1: m_strcpy(buf, sizeof(buf), SYSCONFDIR "/madmutt-mime.types"); @@ -885,7 +1261,7 @@ int mutt_lookup_mime_type (BODY * att, const char *path) p = NULL; } } - fclose (f); + m_fclose(&f); } } @@ -918,12 +1294,12 @@ void mutt_message_to_7bit (BODY * a, FILE * fp) a->offset = 0; if (stat (a->filename, &sb) == -1) { mutt_perror ("stat"); - fclose (fpin); + m_fclose(&fpin); } a->length = sb.st_size; } - fpout = m_tempfile(temp, sizeof(temp), NONULL(Tempdir), NULL); + fpout = m_tempfile(temp, sizeof(temp), NONULL(mod_core.tmpdir), NULL); if (!fpout) { mutt_error(_("Could not create temporary file")); goto cleanup; @@ -946,9 +1322,9 @@ cleanup: p_delete(&line); if (fpin && !fp) - fclose (fpin); + m_fclose(&fpin); if (fpout) - fclose (fpout); + m_fclose(&fpout); else return; @@ -981,21 +1357,21 @@ static void transform_to_7bit (BODY * a, FILE * fpin) transform_to_7bit (a->parts, fpin); } - else if (mutt_is_message_type (a->type, a->subtype)) { + else if (mutt_is_message_type(a)) { mutt_message_to_7bit (a, fpin); } else { a->noconv = 1; a->force_charset = 1; - s.fpout = m_tempfile(buff, sizeof(buff), NONULL(Tempdir), NULL); + s.fpout = m_tempfile(buff, sizeof(buff), NONULL(mod_core.tmpdir), NULL); if (!s.fpout) { mutt_error(_("Could not create temporary file")); return; } s.fpin = fpin; mutt_decode_attachment (a, &s); - fclose (s.fpout); + m_fclose(&s.fpout); a->d_filename = a->filename; a->filename = m_strdup(buff); a->unlink = 1; @@ -1017,7 +1393,7 @@ static void transform_to_7bit (BODY * a, FILE * fpin) /* determine which Content-Transfer-Encoding to use */ static void mutt_set_encoding (BODY * b, CONTENT * info) { - char send_charset[SHORT_STRING]; + char send_charset[STRING]; if (b->type == TYPETEXT) { char *chsname = @@ -1108,12 +1484,10 @@ BODY *mutt_make_message_attach (CONTEXT * ctx, HEADER * hdr, int attach_msg) if ((option (OPTMIMEFORWDECODE) || option (OPTFORWDECRYPT)) && (hdr->security & ENCRYPT)) { - if (!crypt_valid_passphrase (hdr->security)) - return (NULL); } - mutt_mktemp (buffer); - if ((fp = safe_fopen (buffer, "w+")) == NULL) + fp = m_tempfile(buffer, sizeof(buffer), NONULL(mod_core.tmpdir), NULL); + if (!fp) return NULL; body = body_new(); @@ -1167,7 +1541,7 @@ BODY *mutt_make_message_attach (CONTEXT * ctx, HEADER * hdr, int attach_msg) mutt_update_encoding (body); body->parts = body->hdr->content; - fclose (fp); + m_fclose(&fp); return (body); } @@ -1211,16 +1585,17 @@ BODY *mutt_make_file_attach (const char *path) static int get_toplevel_encoding (BODY * a) { - int e = ENC7BIT; + int e = ENC7BIT; - for (; a; a = a->next) { - if (a->encoding == ENCBINARY) - return (ENCBINARY); - else if (a->encoding == ENC8BIT) - e = ENC8BIT; - } + for (; a; a = a->next) { + if (a->encoding == ENCBINARY) + return ENCBINARY; - return (e); + if (a->encoding == ENC8BIT) + e = ENC8BIT; + } + + return e; } BODY *mutt_make_multipart (BODY * b) @@ -1270,68 +1645,56 @@ char *mutt_make_date (char *s, ssize_t len) /* wrapper around mutt_write_address() so we can handle very large recipient lists without needing a huge temporary buffer in memory */ -void mutt_write_address_list (address_t * adr, FILE * fp, int linelen, - int display) +void +mutt_write_address_list(address_t *addr, FILE *fp, int linelen, int display) { - address_t *tmp; - char buf[LONG_STRING]; - int count = 0; - int len; + int first = 1; + + while (addr) { + char buf[LONG_STRING]; + int len = rfc822_addrcpy(buf, ssizeof(buf), addr, display); + + if (!first) { + if (linelen + len > 74) { + fputs("\n\t", fp); + linelen = 8; /* tab is usually about 8 spaces... */ + } else + if (addr->mailbox) { + fputc(' ', fp); + linelen++; + } + } + first = 0; - while (adr) { - tmp = adr->next; - adr->next = NULL; - buf[0] = 0; - rfc822_write_address (buf, sizeof (buf), adr, display); - len = m_strlen(buf); - if (count && linelen + len > 74) { - fputs ("\n\t", fp); - linelen = len + 8; /* tab is usually about 8 spaces... */ - } - else { - if (count && adr->mailbox) { - fputc (' ', fp); - linelen++; - } - linelen += len; - } - fputs (buf, fp); - adr->next = tmp; - if (!adr->group && adr->next && adr->next->mailbox) { - linelen++; - fputc (',', fp); - } - adr = adr->next; - count++; - } - fputc ('\n', fp); -} + linelen += len + 1; + fputs(buf, fp); -/* arbitrary number of elements to grow the array by */ -#define REF_INC 16 + if (!addr->group && addr->next && addr->next->mailbox) { + fputc(',', fp); + linelen++; + } -#define TrimRef 10 + addr = addr->next; + } + fputc ('\n', fp); +} /* need to write the list in reverse because they are stored in reverse order * when parsed to speed up threading */ -void mutt_write_references (string_list_t * r, FILE * f) +void mutt_write_references(string_list_t *r, FILE *f) { - string_list_t **ref = NULL; - int refcnt = 0, refmax = 0; + string_list_t *refs[10]; + int i; - for (; (TrimRef == 0 || refcnt < TrimRef) && r; r = r->next) { - if (refcnt == refmax) - p_realloc(&ref, refmax += REF_INC); - ref[refcnt++] = r; - } - - while (refcnt-- > 0) { - fputc (' ', f); - fputs (ref[refcnt]->data, f); - } + p_clear(refs, countof(refs)); + for (i = 0; i < countof(refs) && r; r = r->next) { + refs[i++] = r; + } - p_delete(&ref); + while (i-- > 0) { + fprintf(f, " %s", refs[i]->data); + } } static int edit_header(int mode, const char *s) @@ -1367,7 +1730,6 @@ static int edit_header(int mode, const char *s) * anonymous remailer chains. * */ - int mutt_write_rfc822_header (FILE * fp, ENVELOPE * env, BODY * attach, int mode, int privacy) { @@ -1387,7 +1749,7 @@ int mutt_write_rfc822_header (FILE * fp, ENVELOPE * env, BODY * attach, */ if (env->from && !privacy) { buffer[0] = 0; - rfc822_write_address (buffer, sizeof (buffer), env->from, 0); + rfc822_addrcat(buffer, sizeof(buffer), env->from, 0); fprintf (fp, "From: %s\n", buffer); } @@ -1436,12 +1798,6 @@ int mutt_write_rfc822_header (FILE * fp, ENVELOPE * env, BODY * attach, fprintf (fp, "Followup-To: %s\n", env->followup_to); else if (mode == 1 && option (OPTNEWSSEND) && edit_header(mode, "Followup-To:")) fputs ("Followup-To:\n", fp); - - if (env->x_comment_to) - fprintf (fp, "X-Comment-To: %s\n", env->x_comment_to); - else if (mode == 1 && option (OPTNEWSSEND) && option (OPTXCOMMENTTO) && - edit_header(mode, "X-Comment-To:")) - fputs ("X-Comment-To:\n", fp); #endif if (env->subject) @@ -1507,16 +1863,12 @@ int mutt_write_rfc822_header (FILE * fp, ENVELOPE * env, BODY * attach, } if (mode == 0 && !privacy && option (OPTXMAILER) && !has_agent) { - const char *os; - - if (OperatingSystem != NULL) { - os = OperatingSystem; + if (mod_core.operating_system) { + fprintf(fp, "User-Agent: %s (%s)\n", mutt_make_version(), + mod_core.operating_system); } else { - struct utsname un; - os = (uname(&un) == -1) ? "UNIX" : un.sysname; + fprintf(fp, "User-Agent: %s\n", mutt_make_version()); } - /* Add a vanity header */ - fprintf (fp, "User-Agent: %s (%s)\n", mutt_make_version (0), os); } return (ferror (fp) == 0 ? 0 : -1); @@ -1542,41 +1894,34 @@ static void encode_headers (string_list_t * h) rfc2047_encode_string (&tmp); p_realloc(&h->data, m_strlen(h->data) + 2 + m_strlen(tmp) + 1); - sprintf (h->data + i, ": %s", NONULL (tmp)); /* __SPRINTF_CHECKED__ */ + sprintf (h->data + i, ": %s", NONULL (tmp)); p_delete(&tmp); } } -const char *mutt_fqdn (short may_hide_host) +const char *mutt_fqdn(short may_hide_host) { char *p = NULL, *q; - if (Fqdn && Fqdn[0] != '@') { - p = Fqdn; + if (mod_core.hostname && mod_core.hostname[0] != '@') { + p = mod_core.hostname; if (may_hide_host && option (OPTHIDDENHOST)) { - if ((p = strchr (Fqdn, '.'))) + if ((p = strchr(mod_core.hostname, '.'))) p++; /* sanity check: don't hide the host if - * the fqdn is something like detebe.org. - */ + the fqdn is something like detebe.org. */ - if (!p || !(q = strchr (p, '.'))) - p = Fqdn; + if (!p || !(q = strchr(p, '.'))) + p = mod_core.hostname; } } return p; } -/* normalized character (we're stricter than RFC2822, 3.6.4) */ -static char mutt_normalized_char(char c) -{ - return (isalnum(c) || strchr(".!#$%&'*+-/=?^_`{|}~", c)) ? c : '.'; -} - static void mutt_gen_localpart(char *buf, unsigned int len, const char *fmt) { #define APPEND_FMT(fmt, arg) \ @@ -1604,7 +1949,8 @@ static void mutt_gen_localpart(char *buf, unsigned int len, const char *fmt) int c = *fmt++; if (c != '%') { - APPEND_BYTE(mutt_normalized_char(c)); + /* normalized character (we're stricter than RFC2822, 3.6.4) */ + APPEND_BYTE((isalnum(c) || strchr(".!#$%&'*+-/=?^_`{|}~", c)) ? c : '.'); continue; } @@ -1656,7 +2002,6 @@ static void mutt_gen_localpart(char *buf, unsigned int len, const char *fmt) break; default: /* invalid formats are replaced by '.' */ APPEND_BYTE('.'); - m_strncat(buf, len, ".", 1); } } @@ -1668,19 +2013,19 @@ static void mutt_gen_localpart(char *buf, unsigned int len, const char *fmt) static char *mutt_gen_msgid (void) { - char buf[SHORT_STRING]; - char localpart[SHORT_STRING]; - const char *fqdn; + char buf[STRING]; + char localpart[STRING]; + const char *fqdn; - if (!(fqdn = mutt_fqdn(0))) - fqdn = NONULL(Hostname); + if (!(fqdn = mutt_fqdn(0))) + fqdn = NONULL(mod_core.shorthost); - mutt_gen_localpart(localpart, sizeof(localpart), MsgIdFormat); - snprintf(buf, sizeof(buf), "<%s@%s>", localpart, fqdn); - return m_strdup(buf); + mutt_gen_localpart(localpart, sizeof(localpart), MsgIdFormat); + snprintf(buf, sizeof(buf), "<%s@%s>", localpart, fqdn); + return m_strdup(buf); } -static RETSIGTYPE alarm_handler (int sig) +static void alarm_handler (int sig __attribute__ ((unused))) { SigAlrm = 1; } @@ -1706,7 +2051,7 @@ send_msg(const char *path, const char **args, const char *msg, char **tempfile) sigaddset (&set, SIGTSTP); sigprocmask (SIG_BLOCK, &set, NULL); - if (SendmailWait >= 0) { + if (MTransport.sendmail_wait >= 0) { char tmp[_POSIX_PATH_MAX]; mutt_mktemp (tmp); @@ -1737,7 +2082,7 @@ send_msg(const char *path, const char **args, const char *msg, char **tempfile) } unlink (msg); - if (SendmailWait >= 0) { + if (MTransport.sendmail_wait >= 0) { /* *tempfile will be opened as stdout */ if (open (*tempfile, O_WRONLY | O_APPEND | O_CREAT | O_EXCL, 0600) < 0) @@ -1745,8 +2090,7 @@ send_msg(const char *path, const char **args, const char *msg, char **tempfile) /* redirect stderr to *tempfile too */ if (dup (1) < 0) _exit (S_ERR); - } - else { + } else { if (open ("/dev/null", O_WRONLY | O_APPEND) < 0) /* stdout */ _exit (S_ERR); if (open ("/dev/null", O_RDWR | O_APPEND) < 0) /* stderr */ @@ -1762,11 +2106,11 @@ send_msg(const char *path, const char **args, const char *msg, char **tempfile) _exit (S_ERR); } - /* SendmailWait > 0: interrupt waitpid() after SendmailWait seconds - * SendmailWait = 0: wait forever - * SendmailWait < 0: don't wait + /* sendmail_wait > 0: interrupt waitpid() after sendmail_wait seconds + * sendmail_wait = 0: wait forever + * sendmail_wait < 0: don't wait */ - if (SendmailWait > 0) { + if (MTransport.sendmail_wait > 0) { SigAlrm = 0; act.sa_handler = alarm_handler; #ifdef SA_INTERRUPT @@ -1777,21 +2121,20 @@ send_msg(const char *path, const char **args, const char *msg, char **tempfile) #endif sigemptyset (&act.sa_mask); sigaction (SIGALRM, &act, &oldalrm); - alarm (SendmailWait); + alarm (MTransport.sendmail_wait); } - else if (SendmailWait < 0) + else if (MTransport.sendmail_wait < 0) _exit (0xff & EX_OK); if (waitpid (pid, &st, 0) > 0) { st = WIFEXITED (st) ? WEXITSTATUS (st) : S_ERR; - if (SendmailWait && st == (0xff & EX_OK)) { + if (MTransport.sendmail_wait && st == (0xff & EX_OK)) { unlink (*tempfile); /* no longer needed */ p_delete(tempfile); } - } - else { - st = (SendmailWait > 0 && errno == EINTR && SigAlrm) ? S_BKG : S_ERR; - if (SendmailWait > 0) { + } else { + st = (MTransport.sendmail_wait > 0 && errno == EINTR && SigAlrm) ? S_BKG : S_ERR; + if (MTransport.sendmail_wait > 0) { unlink (*tempfile); p_delete(tempfile); } @@ -1851,32 +2194,29 @@ static int mutt_invoke_sendmail (address_t * from, /* the sender */ const char *msg, /* file containing message */ int eightbit) { /* message contains 8bit chars */ - char *ps = NULL, *path = NULL, *s = NULL, *childout = NULL; + char cmd[LONG_STRING]; + char *ps = NULL, *path = NULL, *childout = NULL; const char **args = NULL; ssize_t argslen = 0, argsmax = 0; int i; #ifdef USE_NNTP if (option (OPTNEWSSEND)) { - char cmd[LONG_STRING]; - - mutt_FormatString (cmd, sizeof (cmd), NONULL (Inews), nntp_format_str, 0, - 0); - if (!*cmd) { + m_strformat(cmd, sizeof(cmd), 0, Inews, nntp_format_str, 0, 0); + if (m_strisempty(cmd)) { i = nntp_post (msg); unlink (msg); return i; } - - s = m_strdup(cmd); - } - else + } else #endif - s = m_strdup(Sendmail); + { + m_strcpy(cmd, sizeof(cmd), MTransport.sendmail); + } - ps = s; + ps = cmd; i = 0; - while ((ps = strtok (ps, " "))) { + while ((ps = strtok(ps, " "))) { if (argslen == argsmax) p_realloc(&args, argsmax += 5); @@ -1898,27 +2238,25 @@ static int mutt_invoke_sendmail (address_t * from, /* the sender */ #ifdef USE_NNTP if (!option (OPTNEWSSEND)) { #endif - if (eightbit && option (OPTUSE8BITMIME)) + if (eightbit && MTransport.use_8bitmime) args = add_option(args, &argslen, &argsmax, "-B8BITMIME"); - if (option (OPTENVFROM)) { - address_t *f = NULL; - if (EnvFrom) - f = EnvFrom; - else if (from && !from->next) + if (MTransport.use_envelope_from) { + address_t *f = MTransport.envelope_from_address; + if (!f && from && !from->next) f = from; if (f) { args = add_option (args, &argslen, &argsmax, "-f"); args = add_args (args, &argslen, &argsmax, f); } } - if (DsnNotify) { + if (MTransport.dsn_notify) { args = add_option (args, &argslen, &argsmax, "-N"); - args = add_option (args, &argslen, &argsmax, DsnNotify); + args = add_option (args, &argslen, &argsmax, MTransport.dsn_notify); } - if (DsnReturn) { + if (MTransport.dsn_return) { args = add_option (args, &argslen, &argsmax, "-R"); - args = add_option (args, &argslen, &argsmax, DsnReturn); + args = add_option (args, &argslen, &argsmax, MTransport.dsn_return); } args = add_option (args, &argslen, &argsmax, "--"); args = add_args (args, &argslen, &argsmax, to); @@ -1928,7 +2266,7 @@ static int mutt_invoke_sendmail (address_t * from, /* the sender */ } #endif - if (argslen == argsmax) + if (argslen >= argsmax) p_realloc(&args, ++argsmax); args[argslen++] = NULL; @@ -1940,18 +2278,16 @@ static int mutt_invoke_sendmail (address_t * from, /* the sender */ if (childout) { struct stat st; - if (stat (childout, &st) == 0 && st.st_size > 0) - mutt_do_pager (_("Output of the delivery process"), childout, 0, - NULL); + if (!stat(childout, &st) && st.st_size > 0) + mutt_pager(_("Output of the delivery process"), childout, 0, NULL); } } - } - else + } else { unlink (childout); + } p_delete(&childout); p_delete(&path); - p_delete(&s); p_delete(&args); if (i == (EX_OK & 0xff)) @@ -1973,7 +2309,7 @@ int mutt_invoke_mta (address_t * from, /* the sender */ if (!option (OPTNEWSSEND)) #endif if (SmtpHost) - return mutt_libesmtp_invoke (from, to, cc, bcc, msg, eightbit); + return send_smtp_invoke (from, to, cc, bcc, msg, eightbit); #endif return mutt_invoke_sendmail (from, to, cc, bcc, msg, eightbit); @@ -1982,65 +2318,53 @@ int mutt_invoke_mta (address_t * from, /* the sender */ /* For postponing (!final) do the necessary encodings only */ void mutt_prepare_envelope (ENVELOPE * env, int final) { - char buffer[LONG_STRING]; - if (final) { if (env->bcc && !(env->to || env->cc)) { /* some MTA's will put an Apparently-To: header field showing the Bcc: * recipients if there is no To: or Cc: field, so attempt to suppress * it by using an empty To: field. */ - env->to = address_new (); + env->to = address_new(); env->to->group = 1; - env->to->next = address_new (); - - buffer[0] = 0; - rfc822_strcpy(buffer, sizeof(buffer), "undisclosed-recipients", - RFC822Specials); - - env->to->mailbox = m_strdup(buffer); + env->to->next = address_new(); + env->to->mailbox = m_strdup("undisclosed-recipients"); } - mutt_set_followup_to (env); + mutt_set_followup_to(env); - if (!env->message_id && MsgIdFormat && *MsgIdFormat) - env->message_id = mutt_gen_msgid (); + if (!env->message_id && !m_strisempty(MsgIdFormat)) + env->message_id = mutt_gen_msgid(); } /* Take care of 8-bit => 7-bit conversion. */ - rfc2047_encode_adrlist (env->to, "To"); - rfc2047_encode_adrlist (env->cc, "Cc"); - rfc2047_encode_adrlist (env->bcc, "Bcc"); - rfc2047_encode_adrlist (env->from, "From"); - rfc2047_encode_adrlist (env->mail_followup_to, "Mail-Followup-To"); - rfc2047_encode_adrlist (env->reply_to, "Reply-To"); + rfc2047_encode_adrlist(env->to, "To"); + rfc2047_encode_adrlist(env->cc, "Cc"); + rfc2047_encode_adrlist(env->bcc, "Bcc"); + rfc2047_encode_adrlist(env->from, "From"); + rfc2047_encode_adrlist(env->mail_followup_to, "Mail-Followup-To"); + rfc2047_encode_adrlist(env->reply_to, "Reply-To"); if (env->subject) -#ifdef USE_NNTP - if (!option (OPTNEWSSEND) || option (OPTMIMESUBJECT)) -#endif - { - rfc2047_encode_string (&env->subject); - } + rfc2047_encode_string (&env->subject); encode_headers (env->userhdrs); } void mutt_unprepare_envelope (ENVELOPE * env) { - string_list_t *item; + string_list_t *item; - for (item = env->userhdrs; item; item = item->next) - rfc2047_decode (&item->data); + for (item = env->userhdrs; item; item = item->next) + rfc2047_decode(&item->data); - address_list_wipe(&env->mail_followup_to); + address_list_wipe(&env->mail_followup_to); - /* back conversions */ - rfc2047_decode_adrlist (env->to); - rfc2047_decode_adrlist (env->cc); - rfc2047_decode_adrlist (env->bcc); - rfc2047_decode_adrlist (env->from); - rfc2047_decode_adrlist (env->reply_to); - rfc2047_decode (&env->subject); + /* back conversions */ + rfc2047_decode_adrlist(env->to); + rfc2047_decode_adrlist(env->cc); + rfc2047_decode_adrlist(env->bcc); + rfc2047_decode_adrlist(env->from); + rfc2047_decode_adrlist(env->reply_to); + rfc2047_decode(&env->subject); } static int _mutt_bounce_message (FILE * fp, HEADER * h, address_t * to, @@ -2048,7 +2372,7 @@ static int _mutt_bounce_message (FILE * fp, HEADER * h, address_t * to, { int i, ret = 0; FILE *f; - char date[SHORT_STRING], tempfile[_POSIX_PATH_MAX]; + char date[STRING], tempfile[_POSIX_PATH_MAX]; MESSAGE *msg = NULL; if (!h) { @@ -2068,7 +2392,7 @@ static int _mutt_bounce_message (FILE * fp, HEADER * h, address_t * to, if (!fp) fp = msg->fp; - f = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL); + f = m_tempfile(tempfile, sizeof(tempfile), NONULL(mod_core.tmpdir), NULL); if (f) { int ch_flags = CH_XMIT | CH_NONEWLINE | CH_NOQFROM; @@ -2078,14 +2402,14 @@ static int _mutt_bounce_message (FILE * fp, HEADER * h, address_t * to, fseeko (fp, h->offset, 0); fprintf (f, "Resent-From: %s", resent_from); fprintf (f, "\nResent-%s", mutt_make_date (date, sizeof (date))); - if (MsgIdFormat && *MsgIdFormat) - fprintf (f, "Resent-Message-ID: %s\n", mutt_gen_msgid ()); + if (!m_strisempty(MsgIdFormat)) + fprintf (f, "Resent-Message-ID: %s\n", mutt_gen_msgid()); fputs ("Resent-To: ", f); mutt_write_address_list (to, f, 11, 0); mutt_copy_header (fp, h, f, ch_flags, NULL); fputc ('\n', f); mutt_copy_bytes (fp, f, h->content->length); - fclose (f); + m_fclose(&f); ret = mutt_invoke_mta(env_from, to, NULL, NULL, tempfile, h->content->encoding == ENC8BIT); @@ -2100,7 +2424,6 @@ static int _mutt_bounce_message (FILE * fp, HEADER * h, address_t * to, int mutt_bounce_message (FILE * fp, HEADER * h, address_t * to) { address_t *from; - const char *fqdn = mutt_fqdn (1); char resent_from[STRING]; int ret; char *err; @@ -2108,15 +2431,14 @@ int mutt_bounce_message (FILE * fp, HEADER * h, address_t * to) resent_from[0] = '\0'; from = mutt_default_from (); - if (fqdn) - rfc822_qualify (from, fqdn); + rfc822_qualify(from, mutt_fqdn(1)); - rfc2047_encode_adrlist (from, "Resent-From"); + rfc2047_encode_adrlist(from, "Resent-From"); if (mutt_addrlist_to_idna (from, &err)) { mutt_error (_("Bad IDN %s while preparing resent-from."), err); return -1; } - rfc822_write_address (resent_from, sizeof (resent_from), from, 0); + rfc822_addrcat(resent_from, sizeof(resent_from), from, 0); #ifdef USE_NNTP unset_option (OPTNEWSSEND); @@ -2159,8 +2481,8 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, /* We need to add a Content-Length field to avoid problems where a line in * the message body begins with "From " */ - if (f.magic == M_MMDF || f.magic == M_MBOX) { - tempfp = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL); + if (f.magic == M_MBOX) { + tempfp = m_tempfile(tempfile, sizeof(tempfile), NONULL(mod_core.tmpdir), NULL); if (!tempfp) { mutt_error(_("Could not create temporary file")); mx_close_mailbox (&f, NULL); @@ -2177,8 +2499,7 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, /* post == 1 => postpone message. Set mode = -1 in mutt_write_rfc822_header() * post == 0 => Normal mode. Set mode = 0 in mutt_write_rfc822_header() * */ - mutt_write_rfc822_header (msg->fp, hdr->env, hdr->content, post ? -post : 0, - 0); + mutt_write_rfc822_header(msg->fp, hdr->env, hdr->content, -post, 0); /* (postponment) if this was a reply of some sort, contians the * Message-ID: of message replied to. Save it using a special X-Mutt- @@ -2196,8 +2517,6 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, fprintf (msg->fp, "X-Mutt-Fcc: %s\n", fcc); fprintf (msg->fp, "Status: RO\n"); - - /* (postponment) if the mail is to be signed or encrypted, save this info */ if (post && (hdr->security & APPLICATION_PGP)) { fputs ("X-Mutt-PGP: ", msg->fp); @@ -2231,11 +2550,9 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, fputc ('\n', msg->fp); } -#ifdef MIXMASTER /* (postponement) if the mail is to be sent through a mixmaster * chain, save that information */ - if (post && hdr->chain && hdr->chain) { string_list_t *p; @@ -2245,7 +2562,6 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, fputc ('\n', msg->fp); } -#endif if (tempfp) { char sasha[LONG_STRING]; @@ -2265,7 +2581,7 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, fflush (tempfp); if (ferror (tempfp)) { - fclose (tempfp); + m_fclose(&tempfp); unlink (tempfile); mx_commit_message (msg, &f); /* XXX - really? */ mx_close_message (&msg); @@ -2283,13 +2599,12 @@ int mutt_write_fcc (const char *path, HEADER * hdr, const char *msgid, /* copy the body and clean up */ rewind (tempfp); r = mutt_copy_stream (tempfp, msg->fp); - if (fclose (tempfp) != 0) + if (m_fclose(&tempfp) != 0) r = -1; /* if there was an error, leave the temp version */ if (!r) unlink (tempfile); - } - else { + } else { fputc ('\n', msg->fp); /* finish off the header */ r = mutt_write_mime_body (hdr->content, msg->fp); }