/*
 * Copyright 2007-2015, Haiku, Inc. All rights reserved.
 * Copyright 2001-2002 Dr. Zoidberg Enterprises. All rights reserved.
 * Copyright 2011, Clemens Zeidler <haiku@clemens-zeidler.de>
 *
 * Distributed under the terms of the MIT License.
 */


//!     Implementation of the SMTP protocol


#include "SMTP.h"

#include <map>

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>

#include <Alert.h>
#include <Catalog.h>
#include <DataIO.h>
#include <Entry.h>
#include <File.h>
#include <MenuField.h>
#include <Message.h>
#include <Path.h>
#include <Socket.h>
#include <SecureSocket.h>
#include <TextControl.h>

#include <crypt.h>
#include <mail_encoding.h>
#include <MailSettings.h>
#include <NodeMessage.h>
#include <ProtocolConfigView.h>

#include "md5.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "smtp"


#define CRLF "\r\n"
#define SMTP_RESPONSE_SIZE 8192

//#define DEBUG
#ifdef DEBUG
#       define D(x) x
#       define bug printf
#else
#       define D(x) ;
#endif


// Authentication types recognized. Not all methods are implemented.
enum AuthType {
        LOGIN           = 1,
        PLAIN           = 1 << 2,
        CRAM_MD5        = 1 << 3,
        DIGEST_MD5      = 1 << 4
};


using namespace std;

/*
** Function: md5_hmac
** taken from the file rfc2104.txt
** written by Martin Schaaf <mascha@ma-scha.de>
*/
void
MD5Hmac(unsigned char *digest, const unsigned char* text, int text_len,
        const unsigned char* key, int key_len)
{
        MD5_CTX context;
        unsigned char k_ipad[64];
                // inner padding - key XORd with ipad
        unsigned char k_opad[64];
                // outer padding - key XORd with opad
        int i;

        /* start out by storing key in pads */
        memset(k_ipad, 0, sizeof k_ipad);
        memset(k_opad, 0, sizeof k_opad);
        if (key_len > 64) {
                /* if key is longer than 64 bytes reset it to key=MD5(key) */
                MD5_CTX tctx;

                MD5_Init(&tctx);
                MD5_Update(&tctx, (unsigned char*)key, key_len);
                MD5_Final(k_ipad, &tctx);
                MD5_Final(k_opad, &tctx);
        } else {
                memcpy(k_ipad, key, key_len);
                memcpy(k_opad, key, key_len);
        }

        /*
         * the HMAC_MD5 transform looks like:
         *
         * MD5(K XOR opad, MD5(K XOR ipad, text))
         *
         * where K is an n byte key
         * ipad is the byte 0x36 repeated 64 times
         * opad is the byte 0x5c repeated 64 times
         * and text is the data being protected
         */

        /* XOR key with ipad and opad values */
        for (i = 0; i < 64; i++) {
                k_ipad[i] ^= 0x36;
                k_opad[i] ^= 0x5c;
        }

        /*
         * perform inner MD5
         */
        MD5_Init(&context);                   /* init context for 1st
                                               * pass */
        MD5_Update(&context, k_ipad, 64);     /* start with inner pad */
        MD5_Update(&context, (unsigned char*)text, text_len); /* then text of datagram */
        MD5_Final(digest, &context);          /* finish up 1st pass */
        /*
         * perform outer MD5
         */
        MD5_Init(&context);                   /* init context for 2nd
                                               * pass */
        MD5_Update(&context, k_opad, 64);     /* start with outer pad */
        MD5_Update(&context, digest, 16);     /* then results of 1st
                                               * hash */
        MD5_Final(digest, &context);          /* finish up 2nd pass */
}


void
MD5HexHmac(char *hexdigest, const unsigned char* text, int text_len,
        const unsigned char* key, int key_len)
{
        unsigned char digest[16];
        int i;
        unsigned char c;

        MD5Hmac(digest, text, text_len, key, key_len);
        for (i = 0;  i < 16;  i++) {
                c = digest[i];
                *hexdigest++ = (c > 0x9F ? 'a'-10 : '0')+(c>>4);
                *hexdigest++ = ((c&0x0F) > 9 ? 'a'-10 : '0')+(c&0x0F);
        }
        *hexdigest = '\0';
}


/*
** Function: MD5Sum
** generates an MD5-sum from the given string
*/
void
MD5Sum (char* sum, unsigned char *text, int text_len) {
        MD5_CTX context;
        MD5_Init(&context);
        MD5_Update(&context, text, text_len);
        MD5_Final((unsigned char*)sum, &context);
        sum[16] = '\0';
}

/*
** Function: MD5Digest
** generates an MD5-digest from the given string
*/
void MD5Digest (char* hexdigest, unsigned char *text, int text_len) {
        int i;
        unsigned char digest[17];
        unsigned char c;

        MD5Sum((char*)digest, text, text_len);

        for (i = 0;  i < 16;  i++) {
                c = digest[i];
                *hexdigest++ = (c > 0x9F ? 'a'-10 : '0')+(c>>4);
                *hexdigest++ = ((c&0x0F) > 9 ? 'a'-10 : '0')+(c&0x0F);
        }
        *hexdigest = '\0';
}

/*
** Function: SplitChallengeIntoMap
** splits a challenge-string into the given map (see RFC-2831)
*/
// :
static bool
SplitChallengeIntoMap(BString str, map<BString,BString>& m)
{
        m.clear();
        const char* key;
        const char* val;
        char* s = (char*)str.String();
        while(*s != 0) {
                while(isspace(*s))
                        s++;
                key = s;
                while(isalpha(*s))
                        s++;
                if (*s != '=')
                        return false;
                *s++ = '\0';
                while(isspace(*s))
                        s++;
                if (*s=='"') {
                        val = ++s;
                        while(*s!='"') {
                                if (*s == 0)
                                        return false;
                                s++;
                        }
                        *s++ = '\0';
                } else {
                        val = s;
                        while(*s!=0 && *s!=',' && !isspace(*s))
                                s++;
                        if (*s != 0)
                                *s++ = '\0';
                }
                m[key] = val;
                while(isspace(*s))
                        s++;
                if (*s != ',')
                        return false;
                s++;
        }
        return true;
}


// #pragma mark -


SMTPProtocol::SMTPProtocol(const BMailAccountSettings& settings)
        :
        BOutboundMailProtocol("SMTP", settings),
        fAuthType(0)
{
        fSettingsMessage = settings.OutboundSettings();
}


SMTPProtocol::~SMTPProtocol()
{
}


status_t
SMTPProtocol::Connect()
{
        BString errorMessage;
        int32 authMethod = fSettingsMessage.FindInt32("auth_method");

        status_t status = B_ERROR;

        if (authMethod == 2) {
                // POP3 authentication is handled here instead of SMTPProtocol::Login()
                // because some servers obviously don't like establishing the connection
                // to the SMTP server first...
                status_t status = _POP3Authentication();
                if (status < B_OK) {
                        errorMessage << B_TRANSLATE("POP3 authentication failed. The "
                                "server said:\n") << fLog;
                        ShowError(errorMessage.String());
                        return status;
                }
        }

        status = Open(fSettingsMessage.FindString("server"),
                fSettingsMessage.FindInt32("port"), authMethod == 1);
        if (status < B_OK) {
                errorMessage << B_TRANSLATE("Error while opening connection to %serv");
                errorMessage.ReplaceFirst("%serv",
                        fSettingsMessage.FindString("server"));

                if (fSettingsMessage.FindInt32("port") > 0)
                        errorMessage << ":" << fSettingsMessage.FindInt32("port");

                if (fLog.Length() > 0)
                        errorMessage << B_TRANSLATE(". The server says:\n") << fLog;
                else {
                        errorMessage << ". " << strerror(status);
                }

                ShowError(errorMessage.String());

                return status;
        }

        const char* password = get_passwd(&fSettingsMessage, "cpasswd");
        status = Login(fSettingsMessage.FindString("username"), password);
        delete[] password;

        if (status != B_OK) {
                errorMessage << B_TRANSLATE("Error while logging in to %serv")
                        << B_TRANSLATE(". The server said:\n") << fLog;
                errorMessage.ReplaceFirst("%serv",
                        fSettingsMessage.FindString("server"));

                ShowError(errorMessage.String());
        }
        return B_OK;
}


void
SMTPProtocol::Disconnect()
{
        Close();
}


//! Process EMail to be sent
status_t
SMTPProtocol::HandleSendMessages(const BMessage& message, off_t totalBytes)
{
        type_code type;
        int32 count;
        status_t status = message.GetInfo("ref", &type, &count);
        if (status != B_OK)
                return status;

        // TODO: sort out already sent messages -- the request could
        // be issued while we're busy sending them already

        SetTotalItems(count);
        SetTotalItemsSize(totalBytes);

        status = Connect();
        if (status != B_OK)
                return status;

        entry_ref ref;
        for (int32 i = 0; message.FindRef("ref", i++, &ref) == B_OK;) {
                status = _SendMessage(ref);
                if (status != B_OK) {
                        BString error;
                        error << "An error occurred while sending the message "
                                << ref.name << " (" << strerror(status) << "):\n" << fLog;
                        ShowError(error.String());

                        ResetProgress();
                        break;
                }
        }

        Disconnect();
        return B_ERROR;
}


//! Opens connection to server
status_t
SMTPProtocol::Open(const char *address, int port, bool esmtp)
{
        ReportProgress(0, 0, B_TRANSLATE("Connecting to server" B_UTF8_ELLIPSIS));

        use_ssl = (fSettingsMessage.FindInt32("flavor") == 1);

        if (port <= 0)
                port = use_ssl ? 465 : 25;

        BNetworkAddress addr(address);
        if (addr.InitCheck() != B_OK) {
                BString str;
                str.SetToFormat("Invalid network address for SMTP server: %s",
                        strerror(addr.InitCheck()));
                ShowError(str.String());
                return addr.InitCheck();
        }
                
        if (addr.Port() == 0)
                addr.SetPort(port);

        if (use_ssl)
                fSocket = new(std::nothrow) BSecureSocket;
        else
                fSocket = new(std::nothrow) BSocket;
        
        if (!fSocket)
                return B_NO_MEMORY;
        
        if (fSocket->Connect(addr) != B_OK) {
                BString error;
                error << "Could not connect to SMTP server "
                        << fSettingsMessage.FindString("server");
                error << ":" << addr.Port();
                ShowError(error.String());
                delete fSocket;
                return B_ERROR;
        }

        BString line;
        ReceiveResponse(line);

        char localhost[255];
        gethostname(localhost, 255);

        if (localhost[0] == 0)
                strcpy(localhost, "namethisbebox");

        char *cmd = new char[::strlen(localhost)+8];
        if (!esmtp)
                ::sprintf(cmd,"HELO %s" CRLF, localhost);
        else
                ::sprintf(cmd,"EHLO %s" CRLF, localhost);

        if (SendCommand(cmd) != B_OK) {
                delete[] cmd;
                return B_ERROR;
        }

        delete[] cmd;

        // Check auth type
        if (esmtp) {
                const char *res = fLog.String();
                char *p;
                if ((p = ::strstr(res, "250-AUTH")) != NULL
                                || (p = ::strstr(res, "250 AUTH")) != NULL) {
                        if(::strstr(p, "LOGIN"))
                                fAuthType |= LOGIN;
                        if(::strstr(p, "PLAIN"))
                                fAuthType |= PLAIN;
                        if(::strstr(p, "CRAM-MD5"))
                                fAuthType |= CRAM_MD5;
                        if(::strstr(p, "DIGEST-MD5")) {
                                fAuthType |= DIGEST_MD5;
                                fServerName = address;
                        }
                }
        }
        return B_OK;
}


status_t
SMTPProtocol::_SendMessage(const entry_ref& ref)
{
        // open read write to be able to manipulate in MessageReadyToSend hook
        BFile file(&ref, B_READ_WRITE);
        status_t status = file.InitCheck();
        if (status != B_OK)
                return status;

        BMessage header;
        file >> header;

        const char *from = header.FindString("MAIL:from");
        const char *to = header.FindString("MAIL:recipients");
        if (to == NULL)
                to = header.FindString("MAIL:to");

        if (to == NULL || from == NULL) {
                fLog = "Invalid message headers";
                return B_ERROR;
        }

        NotifyMessageReadyToSend(ref, file);
        status = Send(to, from, &file);
        if (status != B_OK)
                return status;
        NotifyMessageSent(ref, file);

        off_t size = 0;
        file.GetSize(&size);
        ReportProgress(size, 1);

        return B_OK;
}


status_t
SMTPProtocol::_POP3Authentication()
{
        const entry_ref& entry = fAccountSettings.InboundAddOnRef();
        if (strcmp(entry.name, "POP3") != 0)
                return B_ERROR;

        status_t (*pop3_smtp_auth)(const BMailAccountSettings&);

        BPath path(&entry);
        image_id image = load_add_on(path.Path());
        if (image < 0)
                return B_ERROR;
        if (get_image_symbol(image, "pop3_smtp_auth",
                        B_SYMBOL_TYPE_TEXT, (void **)&pop3_smtp_auth) != B_OK) {
                unload_add_on(image);
                image = -1;
                return B_ERROR;
        }
        status_t status = (*pop3_smtp_auth)(fAccountSettings);
        unload_add_on(image);
        return status;
}


status_t
SMTPProtocol::Login(const char *_login, const char *password)
{
        if (fAuthType == 0)
                return B_OK;

        const char *login = _login;
        char hex_digest[33];
        BString out;

        int32 loginlen = ::strlen(login);
        int32 passlen = ::strlen(password);

        if (fAuthType & DIGEST_MD5) {
                //******* DIGEST-MD5 Authentication ( tested. works fine [with Cyrus SASL] )
                // this implements only the subpart of DIGEST-MD5 which is
                // required for authentication to SMTP-servers. Integrity-
                // and confidentiality-protection are not implemented, as
                // they are provided by the use of OpenSSL.
                SendCommand("AUTH DIGEST-MD5" CRLF);
                const char *res = fLog.String();

                if (strncmp(res, "334", 3) != 0)
                        return B_ERROR;
                int32 baselen = ::strlen(&res[4]);
                char *base = new char[baselen+1];
                baselen = ::decode_base64(base, &res[4], baselen);
                base[baselen] = '\0';

                D(bug("base: %s\n", base));

                map<BString,BString> challengeMap;
                SplitChallengeIntoMap(base, challengeMap);

                delete[] base;

                BString rawResponse = BString("username=") << '"' << login << '"';
                rawResponse << ",realm=" << '"' << challengeMap["realm"] << '"';
                rawResponse << ",nonce=" << '"' << challengeMap["nonce"] << '"';
                rawResponse << ",nc=00000001";
                char temp[33];
                for( int i=0; i<32; ++i)
                        temp[i] = 1+(rand()%254);
                temp[32] = '\0';
                BString rawCnonce(temp);
                BString cnonce;
                char* cnoncePtr = cnonce.LockBuffer(rawCnonce.Length()*2);
                baselen = ::encode_base64(cnoncePtr, rawCnonce.String(), rawCnonce.Length(), true /* headerMode */);
                cnoncePtr[baselen] = '\0';
                cnonce.UnlockBuffer(baselen);
                rawResponse << ",cnonce=" << '"' << cnonce << '"';
                rawResponse << ",qop=auth";
                BString digestUriValue  = BString("smtp/") << fServerName;
                rawResponse << ",digest-uri=" << '"' << digestUriValue << '"';
                char sum[17], hex_digest2[33];
                BString a1,a2,kd;
                BString t1 = BString(login) << ":"
                                << challengeMap["realm"] << ":"
                                << password;
                MD5Sum(sum, (unsigned char*)t1.String(), t1.Length());
                a1 << sum << ":" << challengeMap["nonce"] << ":" << cnonce;
                MD5Digest(hex_digest, (unsigned char*)a1.String(), a1.Length());
                a2 << "AUTHENTICATE:" << digestUriValue;
                MD5Digest(hex_digest2, (unsigned char*)a2.String(), a2.Length());
                kd << hex_digest << ':' << challengeMap["nonce"]
                   << ":" << "00000001" << ':' << cnonce << ':' << "auth"
                   << ':' << hex_digest2;
                MD5Digest(hex_digest, (unsigned char*)kd.String(), kd.Length());

                rawResponse << ",response=" << hex_digest;
                BString postResponse;
                char *resp = postResponse.LockBuffer(rawResponse.Length() * 2 + 10);
                baselen = ::encode_base64(resp, rawResponse.String(), rawResponse.Length(), true /* headerMode */);
                resp[baselen] = 0;
                postResponse.UnlockBuffer();
                postResponse.Append(CRLF);

                SendCommand(postResponse.String());

                res = fLog.String();
                if (atol(res) >= 500)
                        return B_ERROR;
                // actually, we are supposed to check the rspauth sent back
                // by the SMTP-server, but that isn't strictly required,
                // so we skip that for now.
                SendCommand(CRLF);      // finish off authentication
                res = fLog.String();
                if (atol(res) < 500)
                        return B_OK;
        }
        if (fAuthType & CRAM_MD5) {
                //******* CRAM-MD5 Authentication ( tested. works fine [with Cyrus SASL] )
                SendCommand("AUTH CRAM-MD5" CRLF);
                const char *res = fLog.String();

                if (strncmp(res, "334", 3) != 0)
                        return B_ERROR;
                int32 baselen = ::strlen(&res[4]);
                char *base = new char[baselen+1];
                baselen = ::decode_base64(base, &res[4], baselen);
                base[baselen] = '\0';

                D(bug("base: %s\n", base));

                ::MD5HexHmac(hex_digest, (const unsigned char *)base, (int)baselen,
                        (const unsigned char *)password, (int)passlen);

                D(bug("%s\n%s\n", base, hex_digest));

                delete[] base;

                BString preResponse, postResponse;
                preResponse = login;
                preResponse << " " << hex_digest << CRLF;
                char *resp = postResponse.LockBuffer(preResponse.Length() * 2 + 10);
                baselen = ::encode_base64(resp, preResponse.String(), preResponse.Length(), true /* headerMode */);
                resp[baselen] = 0;
                postResponse.UnlockBuffer();
                postResponse.Append(CRLF);

                SendCommand(postResponse.String());

                res = fLog.String();
                if (atol(res) < 500)
                        return B_OK;
        }
        if (fAuthType & LOGIN) {
                //******* LOGIN Authentication ( tested. works fine)
                ssize_t encodedsize; // required by our base64 implementation

                SendCommand("AUTH LOGIN" CRLF);
                const char *res = fLog.String();

                if (strncmp(res, "334", 3) != 0)
                        return B_ERROR;

                // Send login name as base64
                char *login64 = new char[loginlen*3 + 6];
                encodedsize = ::encode_base64(login64, (char *)login, loginlen, true /* headerMode */);
                login64[encodedsize] = 0;
                strcat (login64, CRLF);
                SendCommand(login64);
                delete[] login64;

                res = fLog.String();
                if (strncmp(res,"334",3) != 0)
                        return B_ERROR;

                // Send password as base64
                login64 = new char[passlen*3 + 6];
                encodedsize = ::encode_base64(login64, (char *)password, passlen, true /* headerMode */);
                login64[encodedsize] = 0;
                strcat (login64, CRLF);
                SendCommand(login64);
                delete[] login64;

                res = fLog.String();
                if (atol(res) < 500)
                        return B_OK;
        }
        if (fAuthType & PLAIN) {
                //******* PLAIN Authentication ( tested. works fine [with Cyrus SASL] )
                // format is:
                //      authenticateID + \0 + username + \0 + password
                //      (where authenticateID is always empty !?!)
                BString preResponse, postResponse;
                char *stringPntr;
                ssize_t encodedLength;
                stringPntr = preResponse.LockBuffer(loginlen + passlen + 3);
                        // +3 to make room for the two \0-chars between the tokens and
                        // the final delimiter added by sprintf().
                sprintf (stringPntr, "%c%s%c%s", 0, login, 0, password);
                preResponse.UnlockBuffer(loginlen + passlen + 2);
                        // +2 in order to leave out the final delimiter (which is not part
                        // of the string).
                stringPntr = postResponse.LockBuffer(preResponse.Length() * 3);
                encodedLength = ::encode_base64(stringPntr, preResponse.String(),
                        preResponse.Length(), true /* headerMode */);
                stringPntr[encodedLength] = 0;
                postResponse.UnlockBuffer();
                postResponse.Prepend("AUTH PLAIN ");
                postResponse << CRLF;

                SendCommand(postResponse.String());

                const char *res = fLog.String();
                if (atol(res) < 500)
                        return B_OK;
        }
        return B_ERROR;
}


void
SMTPProtocol::Close()
{

        BString cmd = "QUIT";
        cmd += CRLF;

        if (SendCommand(cmd.String()) != B_OK) {
                // Error
        }

        delete fSocket;
}


status_t
SMTPProtocol::Send(const char* to, const char* from, BPositionIO *message)
{
        BString cmd = from;
        cmd.Remove(0, cmd.FindFirst("\" <") + 2);
        cmd.Prepend("MAIL FROM: ");
        cmd += CRLF;
        if (SendCommand(cmd.String()) != B_OK)
                return B_ERROR;

        int32 len = strlen(to);
        BString addr("");
        for (int32 i = 0;i < len;i++) {
                char c = to[i];
                if (c != ',')
                        addr += (char)c;
                if (c == ','||i == len-1) {
                        if(addr.Length() == 0)
                                continue;
                        cmd = "RCPT TO: ";
                        cmd << addr.String() << CRLF;
                        if (SendCommand(cmd.String()) != B_OK)
                                return B_ERROR;

                        addr ="";
                }
        }

        cmd = "DATA";
        cmd += CRLF;
        if (SendCommand(cmd.String()) != B_OK)
                return B_ERROR;

        // Send the message data.  Convert lines starting with a period to start
        // with two periods and so on.  The actual sequence is CR LF Period.  The
        // SMTP server will remove the periods.  Of course, the POP server may then
        // add some of its own, but the POP client should take care of them.

        ssize_t amountRead;
        ssize_t amountToRead;
        ssize_t amountUnread;
        ssize_t bufferLen = 0;
        const int bufferMax = 2000;
        bool foundCRLFPeriod;
        int i;
        bool messageEndedWithCRLF = false;

        message->Seek(0, SEEK_END);
        amountUnread = message->Position();
        message->Seek(0, SEEK_SET);
        char *data = new char[bufferMax];

        while (true) {
                // Fill the buffer if it is getting low, but not every time, to avoid
                // small reads.
                if (bufferLen < bufferMax / 2) {
                        amountToRead = bufferMax - bufferLen;
                        if (amountToRead > amountUnread)
                                amountToRead = amountUnread;
                        if (amountToRead > 0) {
                                amountRead = message->Read (data + bufferLen, amountToRead);
                                if (amountRead <= 0 || amountRead > amountToRead)
                                        amountUnread = 0; // Just stop reading when an error happens.
                                else {
                                        amountUnread -= amountRead;
                                        bufferLen += amountRead;
                                }
                        }
                }

                // Look for the next CRLFPeriod triple.
                foundCRLFPeriod = false;
                for (i = 0; i <= bufferLen - 3; i++) {
                        if (data[i] == '\r' && data[i+1] == '\n' && data[i+2] == '.') {
                                foundCRLFPeriod = true;
                                // Send data up to the CRLF, and include the period too.
                                if (fSocket->Write(data, i + 3) < 0) {
                                        amountUnread = 0; // Stop when an error happens.
                                        bufferLen = 0;
                                        break;
                                }
                                ReportProgress (i + 2 /* Don't include the double period here */,0);
                                // Move the data over in the buffer, but leave the period there
                                // so it gets sent a second time.
                                memmove(data, data + (i + 2), bufferLen - (i + 2));
                                bufferLen -= i + 2;
                                break;
                        }
                }

                if (!foundCRLFPeriod) {
                        if (amountUnread <= 0) { // No more data, all we have is in the buffer.
                                if (bufferLen > 0) {
                                        fSocket->Write(data, bufferLen);
                                        ReportProgress(bufferLen, 0);
                                        if (bufferLen >= 2)
                                                messageEndedWithCRLF = (data[bufferLen-2] == '\r' &&
                                                        data[bufferLen-1] == '\n');
                                }
                                break; // Finished!
                        }

                        // Send most of the buffer, except a few characters to overlap with
                        // the next read, in case the CRLFPeriod is split between reads.
                        if (bufferLen > 3) {
                                if (fSocket->Write(data, bufferLen - 3) < 0)
                                        break; // Stop when an error happens.

                                ReportProgress(bufferLen - 3, 0);
                                memmove (data, data + bufferLen - 3, 3);
                                bufferLen = 3;
                        }
                }
        }
        delete [] data;

        if (messageEndedWithCRLF)
                cmd = "." CRLF; // The standard says don't add extra CRLF.
        else
                cmd = CRLF "." CRLF;

        if (SendCommand(cmd.String()) != B_OK)
                return B_ERROR;

        return B_OK;
}


//! Receives response from server.
int32
SMTPProtocol::ReceiveResponse(BString &out)
{
        out = "";
        int32 len = 0,r;
        char buf[SMTP_RESPONSE_SIZE];
        bigtime_t timeout = 1000000*180; // timeout 180 secs
        bool gotCode = false;
        int32 errCode;
        BString searchStr = "";

        if (fSocket->WaitForReadable(timeout) == B_OK) {
                while (1) {
                        r = fSocket->Read(buf, SMTP_RESPONSE_SIZE - 1);
                        if (r <= 0)
                                break;

                        if (!gotCode) {
                                if (buf[3] == ' ' || buf[3] == '-') {
                                        errCode = atol(buf);
                                        gotCode = true;
                                        searchStr << errCode << ' ';
                                }
                        }

                        len += r;
                        out.Append(buf, r);

                        if (strstr(buf, CRLF) && (out.FindFirst(searchStr) != B_ERROR))
                                break;
                }
        } else
                fLog = "SMTP socket timeout.";

        D(bug("S:%s\n", out.String()));
        return len;
}


// Sends SMTP command. Result kept in fLog

status_t
SMTPProtocol::SendCommand(const char *cmd)
{
        D(bug("C:%s\n", cmd));

        if (fSocket->Write(cmd, ::strlen(cmd)) < 0)
                return B_ERROR;
        fLog = "";

        // Receive
        while (1) {
                int32 len = ReceiveResponse(fLog);

                if (len <= 0) {
                        D(bug("SMTP: len == %" B_PRId32 "\n", len));
                        return B_ERROR;
                }

                if (fLog.Length() > 4 && (fLog[3] == ' ' || fLog[3] == '-'))
                {
                        int32 num = atol(fLog.String());
                        D(bug("ReplyNumber: %" B_PRId32 "\n", num));
                        if (num >= 500)
                                return B_ERROR;

                        break;
                }
        }

        return B_OK;
}


// #pragma mark -


extern "C" BOutboundMailProtocol*
instantiate_outbound_protocol(const BMailAccountSettings& settings)
{
        return new SMTPProtocol(settings);
}