smtpc.c

Go to the documentation of this file.

/*
 * Copyright 2010 by egnite GmbH
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 */

/*
 * \file pro/smtpc.c
 * \brief Simple mail transfer protocol client.
 *
 * \verbatim
 * $Id$
 * \endverbatim
 */

#include <sys/nutdebug.h>
#include <sys/confnet.h>
#include <sys/socket.h>

#include <arpa/inet.h>
#include <pro/rfctime.h>

#include <memdebug.h>
#include <string.h>

#include <pro/smtpc.h>


#ifndef SMTP_TIMEOUT
#define SMTP_TIMEOUT    600000
#endif

static void NutBase64Encode(CONST uint8_t * sptr, size_t slen, char *dptr)
{
    static CONST char base64set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    uint_fast8_t i;
    uint32_t blk;
    uint_fast8_t pad = 0;

    /* Normally we do not check for NULL pointers. */
    NUTASSERT(sptr != NULL);
    NUTASSERT(dptr != NULL);

    while (slen) {
        blk = (uint32_t) (*sptr++) << 16;
        if (slen > 1) {
            blk |= (uint32_t) (*sptr++) << 8;
            if (slen > 2) {
                blk |= *sptr++;
            } else {
                pad = 1;
            }
        } else {
            pad = 2;
        }
        for (i = pad; i < 4; i++) {
            *dptr++ = base64set[(blk >> 18) & 63];
            blk <<= 6;
        }
        for (i = 0; i < pad; i++) {
            *dptr++ = '=';
        }
        slen -= 3 - pad;
    }
    *dptr = '\0';
}

CONST char *NutSmtpReceiveResponse(SMTPCLIENTSESSION * si)
{
    char *cp;

    /* Normally we do not check for NULL pointers. */
    NUTASSERT(si != NULL);

    if (fgets(si->smtp_buff, sizeof(si->smtp_buff), si->smtp_stream)) {
        cp = strchr(si->smtp_buff, '\r');
        if (cp == NULL) {
            cp = strchr(si->smtp_buff, '\n');
        }
        if (cp) {
            *cp = '\0';
            return si->smtp_buff;
        }
        /* Line overflow. */
    }
    return NULL;
}

CONST char *NutSmtpSendCommand(SMTPCLIENTSESSION * si, CONST char *fmt, ...)
{
    va_list ap;

    /* Normally we do not check for NULL pointers. */
    NUTASSERT(si != NULL);
    NUTASSERT(fmt != NULL);

    va_start(ap, fmt);
    vfprintf(si->smtp_stream, (char *) fmt, ap);
    va_end(ap);
    fputs("\r\n", si->smtp_stream);
    fflush(si->smtp_stream);

    return NutSmtpReceiveResponse(si);
}

void NutSmtpDisconnect(SMTPCLIENTSESSION * si)
{
    /* Normally we do not check for NULL pointers. */
    NUTASSERT(si != NULL);

    if (si->smtp_sock) {
        if (si->smtp_stream) {
            NutSmtpSendCommand(si, "QUIT");
            fclose(si->smtp_stream);
        }
        NutTcpCloseSocket(si->smtp_sock);
    }
    free(si);
}

SMTPCLIENTSESSION *NutSmtpConnect(uint32_t ip, uint16_t port)
{
    SMTPCLIENTSESSION *si;

    si = calloc(1, sizeof(SMTPCLIENTSESSION));
    if (si) {
        si->smtp_sock = NutTcpCreateSocket();
        if (si->smtp_sock && NutTcpConnect(si->smtp_sock, ip, port) == 0) {
            uint32_t tmo = SMTP_TIMEOUT;
            NutTcpSetSockOpt(si->smtp_sock, SO_RCVTIMEO, &tmo, sizeof(tmo));
            si->smtp_stream = _fdopen((int) ((intptr_t) si->smtp_sock), "r+b");
            if (si->smtp_stream && *NutSmtpReceiveResponse(si) == '2') {
                return si;
            }
        }
        NutSmtpDisconnect(si);
    }
    return NULL;
}

static CONST char *SayHello(SMTPCLIENTSESSION * si, char *cmd, char *host)
{
    if (host) {
        return NutSmtpSendCommand(si, "%s %s", cmd, host);
    }
    return NutSmtpSendCommand(si, "%s [%s]", cmd, inet_ntoa(confnet.cdn_ip_addr));
}

int NutSmtpLogin(SMTPCLIENTSESSION * si, char *host, char *user, char *pass)
{
    CONST char *rsp;

    /* Normally we do not check for NULL pointers. */
    NUTASSERT(si != NULL);

    /* We start an SMTP session by issuing the EHLO command. */
    rsp = SayHello(si, "EHLO", host);
    if (rsp && *rsp == '5') {
        /* If EHLO is not supported, we fall back to HELO. */
        si->smtp_feat |= SMTPFEAT_VINTAGE;
        rsp = SayHello(si, "HELO", host);
    }
    if (rsp && *rsp == '2') {
        if ((si->smtp_feat & SMTPFEAT_VINTAGE) != SMTPFEAT_VINTAGE) {
            for (;;) {
                if (strncmp(rsp + 4, "AUTH ", 5) == 0) {
                    if (strstr(rsp + 9, "LOGIN")) {
                        si->smtp_feat |= SMTPFEAT_AUTH_LOGIN;
                    }
                    if (strstr(rsp + 9, "PLAIN")) {
                        si->smtp_feat |= SMTPFEAT_AUTH_PLAIN;
                    }
                }
                if (*(rsp + 3) != '-') {
                    break;
                }
                rsp = NutSmtpReceiveResponse(si);
                if (rsp == NULL) {
                    break;
                }
            }
        }
        if (user == NULL) {
            /* Return with success, if authorization not required. */
            return 0;
        }
        if (si->smtp_feat & SMTPFEAT_AUTH_PLAIN) {
            int lu = strlen(user);
            int lp = strlen(pass);
            uint8_t *auth = malloc(lu + lp + 3);

            *auth = '\0';
            memcpy(auth + 1, user, lu + 1);
            memcpy(auth + 1 + lu + 1, pass, lp);

            NutBase64Encode(auth, lu + lp + 2, si->smtp_buff);
            rsp = NutSmtpSendCommand(si, "AUTH PLAIN %s", si->smtp_buff);
            if (rsp && *rsp == '2') {
                return 0;
            }
        } else if (si->smtp_feat & SMTPFEAT_AUTH_LOGIN) {
        }
    }
    return -1;
}

int NutSmtpSendMailRequest(SMTPCLIENTSESSION * si, MAILENVELOPE * me)
{
    int rc = 0;
    CONST char *rsp;

    /* Normally we do not check for NULL pointers. */
    NUTASSERT(me != NULL);

    rsp = NutSmtpSendCommand(si, "MAIL FROM:%s", me->mail_from);
    if (rsp && *rsp == '2') {
        int i;

        for (i = 0; i < MAX_MAIL_RCPTS; i++) {
            /* Request all unprocessed recipients. */
            if (me->mail_rcpt[i] && (me->mail_rcpt_stat[i] & MAIL_RCPT_DONE) == 0) {
                rsp = NutSmtpSendCommand(si, "RCPT TO:%s", me->mail_rcpt[i]);
                if (rsp) {
                    if (*rsp == '2') {
                        /* Recipient accepted. */
                        me->mail_rcpt_stat[i] |= MAIL_RCPT_ACPT;
                        rc++;
                    } else {
                        /* Recipient not accepted. */
                        me->mail_rcpt_stat[i] &= ~MAIL_RCPT_ACPT;
                        if (*rsp == '5') {
                            /* Recipient refused. */
                            me->mail_rcpt_stat[i] |= MAIL_RCPT_FAIL;
                        }
                    }
                }
            }
        }
    }
    return rc;
}

static int SendMailHeaderRecipient(FILE *stream, MAILENVELOPE * me, uint8_t type)
{
    uint_fast8_t i;
    int cnt;

    /* Process the list of recipients given by this envelope. */
    for (i = 0, cnt = 0; i < MAX_MAIL_RCPTS; i++) {
        /* Check for the recipient's type. */
        if ((me->mail_rcpt_stat[i] & MAIL_RCPT_TYPE) == type) {
            if (cnt) {
                /* Additional recipient. */
                fputs(",\r\n    ", stream);
            } else {
                /* First one found. */
                fputs(type == MAIL_RCPT_TO ? "To: " : "CC: ", stream);
            }
            fputs(me->mail_rcpt_header[i], stream);
            cnt++;
        }
    }
    if (cnt) {
        fputs("\r\n", stream);
    }
    return 0;
}

int NutSmtpSendMailHeader(SMTPCLIENTSESSION * si, MAILENVELOPE * me)
{
    /* Normally we do not check for NULL pointers. */
    NUTASSERT(si != NULL);
    NUTASSERT(si->smtp_stream != NULL);
    NUTASSERT(me != NULL);

    if (me->mail_date) {
        fprintf(si->smtp_stream, "Date: %s\r\n", Rfc1123TimeString(gmtime(&me->mail_date)));
    }
    fprintf(si->smtp_stream, "From: %s\r\n", me->mail_from_header);
    fprintf(si->smtp_stream, "Subject: %s\r\n", me->mail_subj);
    SendMailHeaderRecipient(si->smtp_stream, me, MAIL_RCPT_TO);
    SendMailHeaderRecipient(si->smtp_stream, me, MAIL_RCPT_CC);

    return 0;
}

int NutSmtpSendEncodedLines(SMTPCLIENTSESSION * si, CONST char *text)
{
    /* Sanity checks. */
    NUTASSERT(si != NULL);
    NUTASSERT(text != NULL);

    while (*text) {
        char *bufp = si->smtp_buff;
        int i;

        /* Collect a line or a complete buffer. */
        for (i = 0; *text && i < SMTP_BUFSIZ; text++) {
            /* Ignore carriage returns. */
            if (*text != '\r') {
                /* Stop at linefeeds or at the end of the message. */
                if (*text == '\n' || *text == '\0') {
                    /* Also send newline. */
                    i++;
                    text++;
                    break;
                } else {
                    /* Send this character unchanged. */
                    *bufp++ = *text;
                    i++;
                }
            }
        }
        if (i) {
            *bufp = '\0';
            /* Insert a dot in front of any line that starts with a dot. */
            if (si->smtp_buff[0] == '.') {
                fputc('.', si->smtp_stream);
            }
            /* Send the buffer with CR/LF appended. */
            fputs(si->smtp_buff, si->smtp_stream);
            if (fputs("\r\n", si->smtp_stream) == EOF) {
                /* Connection broken. */
                return -1;
            }
        }
    }
    return 0;
}

CONST char *NutSmtpSendMail(SMTPCLIENTSESSION * si, MAILENVELOPE * me)
{
    CONST char *rsp = NULL;

    /* Normally we do not check for NULL pointers. */
    NUTASSERT(si != NULL);
    NUTASSERT(me != NULL);

    /* Send a request for sending mail. The function returns the number
       of accepted recipients. */
    if (NutSmtpSendMailRequest(si, me) > 0) {
        /* Start sending the email. */
        rsp = NutSmtpSendCommand(si, "DATA");
        /* Server wants us to go ahead? */
        if (rsp && *rsp == '3') {
            /* Send the major header lines. */
            NutSmtpSendMailHeader(si, me);
            fputs("\r\n", si->smtp_stream);
            /* If available, send the mail body's text. */
            if (me->mail_body) {
                NutSmtpSendEncodedLines(si, me->mail_body);
            }
            fputs(".\r\n", si->smtp_stream);
            fflush(si->smtp_stream);
            /* Check the result of the data transfer. */
            rsp = NutSmtpReceiveResponse(si);
            /* On success, update the status of the previously accepted
               recipients. */
            if (rsp && *rsp == '2') {
                uint_fast8_t i;
                for (i = 0; i < MAX_MAIL_RCPTS; i++) {
                    if (me->mail_rcpt[i]) {
                        if ((me->mail_rcpt_stat[i] & MAIL_RCPT_ACPT) == MAIL_RCPT_ACPT) {
                            me->mail_rcpt_stat[i] |= MAIL_RCPT_SENT;
                        }
                    }
                }
            }
        }
    }
    return rsp;
}