/* Fetch messages and save them in $spoolfile */
void pop_fetch_mail(void)
{
char buffer[LONG_STRING];
char msgbuf[SHORT_STRING];
char *url, *p;
int i, delanswer, last = 0, msgs, bytes, rset = 0, ret;
CONNECTION *conn;
CONTEXT ctx;
MESSAGE *msg = NULL;
ACCOUNT acct;
POP_DATA *pop_data;
if (!PopHost) {
mutt_error _("POP host is not defined.");
return;
}
url = p = safe_calloc(strlen(PopHost) + 7, sizeof(char));
if (url_check_scheme(PopHost) == U_UNKNOWN) {
strcpy(url, "pop://"); /* __STRCPY_CHECKED__ */
p = strchr(url, '\0');
}
strcpy(p, PopHost); /* __STRCPY_CHECKED__ */
ret = pop_parse_path(url, &acct);
safe_free(&url);
if (ret) {
mutt_error(_("%s is an invalid POP path"), PopHost);
return;
}
conn = mutt_conn_find(NULL, &acct);
if (!conn)
return;
pop_data = safe_calloc(1, sizeof(POP_DATA));
pop_data->conn = conn;
if (pop_open_connection(pop_data) < 0) {
mutt_socket_free(pop_data->conn);
safe_free(&pop_data);
return;
}
conn->data = pop_data;
mutt_message _("Checking for new messages...");
/* find out how many messages are in the mailbox. */
strfcpy(buffer, "STAT\r\n", sizeof(buffer));
ret = pop_query(pop_data, buffer, sizeof(buffer));
if (ret == -1)
goto fail;
if (ret == -2) {
mutt_error("%s", pop_data->err_msg);
goto finish;
}
sscanf(buffer, "+OK %d %d", &msgs, &bytes);
/* only get unread messages */
if ((msgs > 0)
&& option(OPTPOPLAST)) {
strfcpy(buffer, "LAST\r\n", sizeof(buffer));
ret = pop_query(pop_data, buffer, sizeof(buffer));
if (ret == -1)
goto fail;
if (ret == 0)
sscanf(buffer, "+OK %d", &last);
}
if (msgs <= last) {
mutt_message _("No new mail in POP mailbox.");
goto finish;
}
if (mx_open_mailbox(NONULL(Spoolfile), M_APPEND, &ctx) == NULL)
goto finish;
delanswer = query_quadoption(OPT_POPDELETE, _(
"Delete messages from server?"));
snprintf(msgbuf, sizeof(msgbuf), _(
"Reading new messages (%d bytes)..."), bytes);
mutt_message("%s", msgbuf);
for (i = last + 1; i <= msgs; i++) {
if ((msg = mx_open_new_message(&ctx, NULL, M_ADD_FROM)) == NULL)
ret = -3;
else {
snprintf(buffer, sizeof(buffer), "RETR %d\r\n", i);
ret =
pop_fetch_data(pop_data, buffer, NULL, fetch_message, msg->fp);
if (ret == -3)
rset = 1;
if ((ret == 0)
&& (mx_commit_message(msg, &ctx) != 0)) {
rset = 1;
ret = -3;
}
mx_close_message(&msg);
}
if ((ret == 0)
&& (delanswer == M_YES)) {
/* delete the message on the server */
snprintf(buffer, sizeof(buffer), "DELE %d\r\n", i);
ret = pop_query(pop_data, buffer, sizeof(buffer));
}
if (ret == -1) {
mx_close_mailbox(&ctx, NULL);
goto fail;
}
if (ret == -2) {
mutt_error("%s", pop_data->err_msg);
break;
}
if (ret == -3) {
mutt_error _("Error while writing mailbox!");
break;
}
mutt_message(_(
"%s [%d of %d messages read]"), msgbuf, i - last,
msgs - last);
}
mx_close_mailbox(&ctx, NULL);
if (rset) {
/* make sure no messages get deleted */
strfcpy(buffer, "RSET\r\n", sizeof(buffer));
if (pop_query(pop_data, buffer, sizeof(buffer)) == -1)
goto fail;
}
finish:
/* exit gracefully */
strfcpy(buffer, "QUIT\r\n", sizeof(buffer));
if (pop_query(pop_data, buffer, sizeof(buffer)) == -1)
goto fail;
mutt_socket_close(conn);
safe_free(&pop_data);
return;
fail:
mutt_error _("Server closed connection!");
mutt_socket_close(conn);
safe_free(&pop_data);
}
int
mutt_smtp_send (const ADDRESS* from, const ADDRESS* to, const ADDRESS* cc,
const ADDRESS* bcc, const char *msgfile, int eightbit)
{
CONNECTION *conn;
ACCOUNT account;
const char* envfrom;
char buf[1024];
int ret = -1;
/* it might be better to synthesize an envelope from from user and host
* but this condition is most likely arrived at accidentally */
if (EnvFrom)
envfrom = EnvFrom->mailbox;
else if (from)
envfrom = from->mailbox;
else {
mutt_error (_("No from address given"));
return -1;
}
if (smtp_fill_account (&account) < 0)
return ret;
if (!(conn = mutt_conn_find (NULL, &account)))
return -1;
Esmtp = eightbit;
do {
/* send our greeting */
if (( ret = smtp_open (conn)))
break;
FREE (&AuthMechs);
/* send the sender's address */
ret = snprintf (buf, sizeof (buf), "MAIL FROM:<%s>", envfrom);
if (eightbit && mutt_bit_isset (Capabilities, EIGHTBITMIME)) {
safe_strncat (buf, sizeof (buf), " BODY=8BITMIME", 15);
ret += 14;
}
if (DsnReturn && mutt_bit_isset (Capabilities, DSN))
ret += snprintf (buf + ret, sizeof (buf) - ret, " RET=%s", DsnReturn);
safe_strncat (buf, sizeof (buf), "\r\n", 3);
if (mutt_socket_write (conn, buf) == -1) {
ret = smtp_err_write;
break;
}
if ((ret = smtp_get_resp (conn)))
break;
/* send the recipient list */
if ((ret = smtp_rcpt_to (conn, to)) || (ret = smtp_rcpt_to (conn, cc))
|| (ret = smtp_rcpt_to (conn, bcc)))
break;
/* send the message data */
if ((ret = smtp_data (conn, msgfile)))
break;
mutt_socket_write (conn, "QUIT\r\n");
ret = 0;
}
while (0);
if (conn)
mutt_socket_close (conn);
if (ret == smtp_err_read)
mutt_error (_("SMTP session failed: read error"));
else if (ret == smtp_err_write)
mutt_error (_("SMTP session failed: write error"));
else if (ret == smtp_err_code)
mutt_error (_("Invalid server response"));
return ret;
}
/* open POP mailbox - fetch only headers */
int pop_open_mailbox(CONTEXT *ctx)
{
int ret;
char buf[LONG_STRING];
CONNECTION *conn;
ACCOUNT acct;
POP_DATA *pop_data;
ciss_url_t url;
if (pop_parse_path(ctx->path, &acct)) {
mutt_error(_("%s is an invalid POP path"), ctx->path);
mutt_sleep(2);
return -1;
}
mutt_account_tourl(&acct, &url);
url.path = NULL;
url_ciss_tostring(&url, buf, sizeof(buf), 0);
conn = mutt_conn_find(NULL, &acct);
if (!conn)
return -1;
safe_free(&ctx->path);
ctx->path = safe_strdup(buf);
pop_data = safe_calloc(1, sizeof(POP_DATA));
pop_data->conn = conn;
ctx->data = pop_data;
ctx->mx_close = pop_close_mailbox;
if (pop_open_connection(pop_data) < 0)
return -1;
conn->data = pop_data;
pop_data->bcache = mutt_bcache_open(&acct, NULL);
/* init (hard-coded) ACL rights */
memset(ctx->rights, 0, sizeof(ctx->rights));
mutt_bit_set(ctx->rights, M_ACL_SEEN);
mutt_bit_set(ctx->rights, M_ACL_DELETE);
FOREVER
{
if (pop_reconnect(ctx) < 0)
return -1;
ctx->size = pop_data->size;
mutt_message _("Fetching list of messages...");
ret = pop_fetch_headers(ctx);
if (ret >= 0)
return 0;
if (ret < -1) {
mutt_sleep(2);
return -1;
}
}
}
