blob: e0a95559674d627a9143110ccd79103316702e6c [file] [log] [blame]
/*
* libwebsockets - small server side websockets and web server implementation
*
* Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "private-lib-core.h"
#include "private-lib-abstract.h"
/** enum lwsgs_smtp_states - where we are in SMTP protocol sequence */
typedef enum lwsgs_smtp_states {
LGSSMTP_IDLE, /**< awaiting new email */
LGSSMTP_CONNECTING, /**< opening tcp connection to MTA */
LGSSMTP_CONNECTED, /**< tcp connection to MTA is connected */
/* (server sends greeting) */
LGSSMTP_SENT_HELO, /**< sent the HELO */
LGSSMTP_SENT_FROM, /**< sent FROM */
LGSSMTP_SENT_TO, /**< sent TO */
LGSSMTP_SENT_DATA, /**< sent DATA request */
LGSSMTP_SENT_BODY, /**< sent the email body */
/*
* (server sends, eg, "250 Ok: queued as 12345")
* at this point we can return to LGSSMTP_SENT_HELO and send a
* new email, or continue below to QUIT, or just wait
*/
LGSSMTP_SENT_QUIT, /**< sent the session quit */
/* (server sends, eg, "221 Bye" and closes the connection) */
} lwsgs_smtp_states_t;
/** abstract protocol instance data */
typedef struct lws_smtp_client_protocol {
const struct lws_abs *abs;
lwsgs_smtp_states_t estate;
lws_smtp_email_t *e; /* the email we are trying to send */
const char *helo;
unsigned char send_pending:1;
} lws_smtpcp_t;
static const short retcodes[] = {
0, /* idle */
0, /* connecting */
220, /* connected */
250, /* helo */
250, /* from */
250, /* to */
354, /* data */
250, /* body */
221, /* quit */
};
static void
lws_smtpc_state_transition(lws_smtpcp_t *c, lwsgs_smtp_states_t s)
{
lwsl_debug("%s: cli %p: state %d -> %d\n", __func__, c, c->estate, s);
c->estate = s;
}
static lws_smtp_email_t *
lws_smtpc_get_email(lws_smtpcp_t *c)
{
const lws_token_map_t *tm;
/* ... the email we want to send */
tm = lws_abs_get_token(c->abs->ap_tokens, LTMI_PSMTP_V_LWS_SMTP_EMAIL_T);
if (!tm) {
assert(0);
return NULL;
}
return (lws_smtp_email_t *)tm->u.value;
}
/*
* Called when something happened so that we know now the final disposition of
* the email send attempt, for good or ill.
*
* Inform the owner via the done callback and set up the next queued one if any.
*
* Returns nonzero if we queued a new one
*/
static int
lws_smtpc_email_disposition(lws_smtpcp_t *c, int disp, const void *buf,
size_t len)
{
lws_smtpcp_t *ch;
lws_abs_t *ach;
lws_dll2_t *d;
lws_smtpc_state_transition(c, LGSSMTP_SENT_HELO);
/* lifetime of the email object is handled by done callback */
c->e->done(c->e, c->e->data, disp, buf, len);
c->e = NULL;
/* this may not be the time to try to send anything else... */
if (disp == LWS_SMTP_DISPOSITION_FAILED_DESTROY)
return 0;
/* ... otherwise... do we have another queued? */
d = lws_dll2_get_tail(&c->abs->children_owner);
if (!d)
return 0;
ach = lws_container_of(d, lws_abs_t, bound);
ch = (lws_smtpcp_t *)ach->api;
c->e = lws_smtpc_get_email(ch);
/* since we took it on, remove it from the queue */
lws_dll2_remove(d);
return 1;
}
/*
* we became connected
*/
static int
lws_smtpc_abs_accept(lws_abs_protocol_inst_t *api)
{
lws_smtpcp_t *c = (lws_smtpcp_t *)api;
/* we have become connected in the tcp sense */
lws_smtpc_state_transition(c, LGSSMTP_CONNECTED);
/*
* From the accept(), the next thing that should happen is the SMTP
* server sends its greeting like "220 smtp2.example.com ESMTP Postfix",
* we'll hear about it in the rx callback, or time out
*/
c->abs->at->set_timeout(c->abs->ati,
PENDING_TIMEOUT_AWAITING_SERVER_RESPONSE, 3);
return 0;
}
static int
lws_smtpc_abs_rx(lws_abs_protocol_inst_t *api, const uint8_t *buf, size_t len)
{
lws_smtpcp_t *c = (lws_smtpcp_t *)api;
char dotstar[96], at[5];
int n;
c->abs->at->set_timeout(c->abs->ati, NO_PENDING_TIMEOUT, 0);
lws_strncpy(at, (const char *)buf, sizeof(at));
n = atoi(at);
switch (c->estate) {
case LGSSMTP_CONNECTED:
if (n != 220) {
/*
* The server did not properly greet us... we can't
* even get started, so fail the transport connection
* (and anything queued on it)
*/
lws_strnncpy(dotstar, (const char *)buf, len, sizeof(dotstar));
lwsl_err("%s: server: %s\n", __func__, dotstar);
return 1;
}
break;
case LGSSMTP_SENT_BODY:
/*
* We finished one way or another... let's prepare to send a
* new one... or wait until server hangs up on us
*/
if (!lws_smtpc_email_disposition(c,
n == 250 ? LWS_SMTP_DISPOSITION_SENT :
LWS_SMTP_DISPOSITION_FAILED,
"destroyed", 0))
return 0; /* become idle */
break; /* ask to send */
case LGSSMTP_SENT_QUIT:
lwsl_debug("%s: done\n", __func__);
lws_smtpc_state_transition(c, LGSSMTP_IDLE);
return 1;
default:
if (n != retcodes[c->estate]) {
lws_strnncpy(dotstar, buf, len, sizeof(dotstar));
lwsl_notice("%s: bad response: %d (state %d) %s\n",
__func__, n, c->estate, dotstar);
lws_smtpc_email_disposition(c,
LWS_SMTP_DISPOSITION_FAILED, buf, len);
return 0;
}
break;
}
c->send_pending = 1;
c->abs->at->ask_for_writeable(c->abs->ati);
return 0;
}
static int
lws_smtpc_abs_writeable(lws_abs_protocol_inst_t *api, size_t budget)
{
char b[256 + LWS_PRE], *p = b + LWS_PRE;
lws_smtpcp_t *c = (lws_smtpcp_t *)api;
int n;
if (!c->send_pending || !c->e)
return 0;
c->send_pending = 0;
lwsl_debug("%s: writing response for state %d\n", __func__, c->estate);
switch (c->estate) {
case LGSSMTP_CONNECTED:
n = lws_snprintf(p, sizeof(b) - LWS_PRE, "HELO %s\n", c->helo);
lws_smtpc_state_transition(c, LGSSMTP_SENT_HELO);
break;
case LGSSMTP_SENT_HELO:
n = lws_snprintf(p, sizeof(b) - LWS_PRE, "MAIL FROM: <%s>\n",
c->e->from);
lws_smtpc_state_transition(c, LGSSMTP_SENT_FROM);
break;
case LGSSMTP_SENT_FROM:
n = lws_snprintf(p, sizeof(b) - LWS_PRE,
"RCPT TO: <%s>\n", c->e->to);
lws_smtpc_state_transition(c, LGSSMTP_SENT_TO);
break;
case LGSSMTP_SENT_TO:
n = lws_snprintf(p, sizeof(b) - LWS_PRE, "DATA\n");
lws_smtpc_state_transition(c, LGSSMTP_SENT_DATA);
break;
case LGSSMTP_SENT_DATA:
p = (char *)&c->e[1];
n = strlen(p);
lws_smtpc_state_transition(c, LGSSMTP_SENT_BODY);
break;
case LGSSMTP_SENT_BODY:
n = lws_snprintf(p, sizeof(b) - LWS_PRE, "quit\n");
lws_smtpc_state_transition(c, LGSSMTP_SENT_QUIT);
break;
case LGSSMTP_SENT_QUIT:
return 0;
default:
return 0;
}
//puts(p);
c->abs->at->tx(c->abs->ati, (uint8_t *)p, n);
return 0;
}
static int
lws_smtpc_abs_closed(lws_abs_protocol_inst_t *api)
{
lws_smtpcp_t *c = (lws_smtpcp_t *)api;
if (c)
lws_smtpc_state_transition(c, LGSSMTP_IDLE);
return 0;
}
/*
* Creating for initial transport and for piggybacking on another transport
* both get created here the same. But piggybackers have ai->bound attached.
*/
static int
lws_smtpc_create(const lws_abs_t *ai)
{
lws_smtpcp_t *c = (lws_smtpcp_t *)ai->api;
memset(c, 0, sizeof(*c));
c->abs = ai;
c->e = lws_smtpc_get_email(c);
lws_smtpc_state_transition(c, lws_dll2_is_detached(&ai->bound) ?
LGSSMTP_CONNECTING : LGSSMTP_IDLE);
/* If we are initiating the transport, we will get an accept() next...
*
* If we are piggybacking, the parent will get a .child_bind() after
* this to give it a chance to act on us joining (eg, it was completely
* idle and we joined).
*/
return 0;
}
static void
lws_smtpc_destroy(lws_abs_protocol_inst_t **_c)
{
lws_smtpcp_t *c = (lws_smtpcp_t *)*_c;
if (!c)
return;
/* so if we are still holding on to c->e, we have failed to send it */
if (c->e)
lws_smtpc_email_disposition(c,
LWS_SMTP_DISPOSITION_FAILED_DESTROY, "destroyed", 0);
*_c = NULL;
}
static int
lws_smtpc_compare(lws_abs_t *abs1, lws_abs_t *abs2)
{
return 0;
}
static int
lws_smtpc_child_bind(lws_abs_t *abs)
{
return 0;
}
/* events the transport invokes (handled by abstract protocol) */
const lws_abs_protocol_t lws_abs_protocol_smtp = {
.name = "smtp",
.alloc = sizeof(lws_smtpcp_t),
.flags = LWSABSPR_FLAG_PIPELINE,
.create = lws_smtpc_create,
.destroy = lws_smtpc_destroy,
.compare = lws_smtpc_compare,
.accept = lws_smtpc_abs_accept,
.rx = lws_smtpc_abs_rx,
.writeable = lws_smtpc_abs_writeable,
.closed = lws_smtpc_abs_closed,
.heartbeat = NULL,
.child_bind = lws_smtpc_child_bind,
};