/*
 * Copyright 2007-2016, 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.
 */
 
 
//! POP3Protocol - implementation of the POP3 protocol
 
 
#include "POP3.h"
 
#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
 
#include <arpa/inet.h>
 
#include "md5.h"
 
#include <Alert.h>
#include <Catalog.h>
#include <Debug.h>
#include <Directory.h>
#include <fs_attr.h>
#include <Path.h>
#include <SecureSocket.h>
#include <String.h>
#include <VolumeRoster.h>
#include <Query.h>
 
#include <mail_util.h>
 
#include "crypt.h"
#include "MailSettings.h"
#include "MessageIO.h"
 
 
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "pop3"
 
 
#define POP3_RETRIEVAL_TIMEOUT 60000000
#define CRLF	"\r\n"
 
 
static void
NotHere(BStringList& that, BStringList& otherList, BStringList* results)
{
	for (int32 i = 0; i < otherList.CountStrings(); i++) {
		if (!that.HasString(otherList.StringAt(i)))
			results->Add(otherList.StringAt(i));
	}
}
 
 
// #pragma mark -
 
 
POP3Protocol::POP3Protocol(const BMailAccountSettings& settings)
	:
	BInboundMailProtocol("POP3", settings),
	fNumMessages(-1),
	fMailDropSize(0),
	fServerConnection(NULL)
{
	printf("POP3Protocol::POP3Protocol(BMailAccountSettings* settings)\n");
	fSettings = fAccountSettings.InboundSettings();
 
	fUseSSL = fSettings.FindInt32("flavor") == 1 ? true : false;
 
	if (fSettings.FindString("destination", &fDestinationDir) != B_OK)
		fDestinationDir = "/boot/home/mail/in";
 
	create_directory(fDestinationDir, 0777);
 
	fFetchBodyLimit = -1;
	if (fSettings.HasInt32("partial_download_limit"))
		fFetchBodyLimit = fSettings.FindInt32("partial_download_limit");
}
 
 
POP3Protocol::~POP3Protocol()
{
	Disconnect();
}
 
 
status_t
POP3Protocol::Connect()
{
	status_t error = Open(fSettings.FindString("server"),
		fSettings.FindInt32("port"), fSettings.FindInt32("flavor"));
	if (error != B_OK)
		return error;
 
	char* password = get_passwd(&fSettings, "cpasswd");
 
	error = Login(fSettings.FindString("username"), password,
		fSettings.FindInt32("auth_method"));
	delete[] password;
 
	if (error != B_OK)
		fServerConnection->Disconnect();
	return error;
}
 
 
status_t
POP3Protocol::Disconnect()
{
	if (fServerConnection == NULL)
		return B_OK;
 
	SendCommand("QUIT" CRLF);
 
	fServerConnection->Disconnect();
	delete fServerConnection;
	fServerConnection = NULL;
 
	return B_OK;
}
 
 
status_t
POP3Protocol::SyncMessages()
{
	bool leaveOnServer;
	if (fSettings.FindBool("leave_mail_on_server", &leaveOnServer) != B_OK)
		leaveOnServer = true;
 
	// create directory if not exist
	create_directory(fDestinationDir, 0777);
 
	printf("POP3Protocol::SyncMessages()\n");
	_ReadManifest();
 
	SetTotalItems(2);
	ReportProgress(1, 0, B_TRANSLATE("Connect to server" B_UTF8_ELLIPSIS));
 
	status_t error = Connect();
	if (error != B_OK) {
		printf("POP3 could not connect: %s\n", strerror(error));
		ResetProgress();
		return error;
	}
 
	ReportProgress(1, 0, B_TRANSLATE("Getting UniqueIDs" B_UTF8_ELLIPSIS));
 
	error = _RetrieveUniqueIDs();
	if (error < B_OK) {
		ResetProgress();
		Disconnect();
		return error;
	}
 
	BStringList toDownload;
	NotHere(fManifest, fUniqueIDs, &toDownload);
 
	int32 numMessages = toDownload.CountStrings();
	if (numMessages == 0) {
		CheckForDeletedMessages();
		ResetProgress();
		Disconnect();
		return B_OK;
	}
 
	ResetProgress();
	SetTotalItems(toDownload.CountStrings());
	SetTotalItemsSize(fTotalSize);
 
	printf("POP3: Messages to download: %i\n", (int)toDownload.CountStrings());
	for (int32 i = 0; i < toDownload.CountStrings(); i++) {
		const char* uid = toDownload.StringAt(i);
		int32 toRetrieve = fUniqueIDs.IndexOf(uid);
 
		if (toRetrieve < 0) {
			// should not happen!
			error = B_NAME_NOT_FOUND;
			printf("POP3: uid %s index %i not found in fUniqueIDs!\n", uid,
				(int)toRetrieve);
			continue;
		}
 
		BPath path(fDestinationDir);
		BString fileName = "Downloading file... uid: ";
		fileName += uid;
		fileName.ReplaceAll("/", "_SLASH_");
		path.Append(fileName);
		BEntry entry(path.Path());
		BFile file(&entry, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
		error = file.InitCheck();
		if (error != B_OK) {
			printf("POP3: Can't create file %s\n ", path.Path());
			break;
		}
		BMailMessageIO mailIO(this, &file, toRetrieve);
		BMessage attributes;
 
		entry_ref ref;
		entry.GetRef(&ref);
 
		int32 size = MessageSize(toRetrieve);
		if (fFetchBodyLimit < 0 || size <= fFetchBodyLimit) {
			error = mailIO.Seek(0, SEEK_END);
			if (error < 0) {
				printf("POP3: Failed to download body %s\n ", uid);
				break;
			}
			ProcessMessageFetched(ref, file, attributes);
 
			if (!leaveOnServer)
				Delete(toRetrieve);
		} else {
			int32 dummy;
			error = mailIO.ReadAt(0, &dummy, 1);
			if (error < 0) {
				printf("POP3: Failed to download header %s\n ", uid);
				break;
			}
			ProcessHeaderFetched(ref, file, attributes);
		}
		ReportProgress(1, 0);
 
		const BString uidStr(uid);
		if (file.WriteAttrString("MAIL:unique_id", &uidStr) < 0)
			error = B_ERROR;
 
		file.WriteAttr("MAIL:size", B_INT32_TYPE, 0, &size, sizeof(int32));
		write_read_attr(file, B_UNREAD);
 
		// save manifest in case we get disturbed
		fManifest.Add(uid);
		_WriteManifest();
	}
 
	ResetProgress();
 
	CheckForDeletedMessages();
	Disconnect();
	return error;
}
 
 
status_t
POP3Protocol::HandleFetchBody(const entry_ref& ref, const BMessenger& replyTo)
{
	ResetProgress("Fetch body");
	SetTotalItems(1);
 
	status_t error = Connect();
	if (error != B_OK)
		return error;
 
	error = _RetrieveUniqueIDs();
	if (error != B_OK) {
		Disconnect();
		return error;
	}
 
	BFile file(&ref, B_READ_WRITE);
	status_t status = file.InitCheck();
	if (status != B_OK) {
		Disconnect();
		return status;
	}
 
	char uidString[256];
	BNode node(&ref);
	if (node.ReadAttr("MAIL:unique_id", B_STRING_TYPE, 0, uidString, 256) < 0) {
		Disconnect();
		return B_ERROR;
	}
 
	int32 toRetrieve = fUniqueIDs.IndexOf(uidString);
	if (toRetrieve < 0) {
		Disconnect();
		return B_NAME_NOT_FOUND;
	}
 
	bool leaveOnServer;
	if (fSettings.FindBool("leave_mail_on_server", &leaveOnServer) != B_OK)
		leaveOnServer = true;
 
	// TODO: get rid of this BMailMessageIO!
	BMailMessageIO io(this, &file, toRetrieve);
	// read body
	status = io.Seek(0, SEEK_END);
	if (status < 0) {
		Disconnect();
		return status;
	}
 
	BMessage attributes;
	NotifyBodyFetched(ref, file, attributes);
	ReplyBodyFetched(replyTo, ref, B_OK);
 
	if (!leaveOnServer)
		Delete(toRetrieve);
 
	ReportProgress(1, 0);
	ResetProgress();
 
	Disconnect();
	return B_OK;
}
 
 
status_t
POP3Protocol::Open(const char* server, int port, int)
{
	ReportProgress(0, 0, B_TRANSLATE("Connecting to POP3 server"
		B_UTF8_ELLIPSIS));
 
	if (port <= 0)
		port = fUseSSL ? 995 : 110;
 
	fLog = "";
 
	// Prime the error message
	BString errorMessage(B_TRANSLATE("Error while connecting to server %serv"));
	errorMessage.ReplaceFirst("%serv", server);
	if (port != 110)
		errorMessage << ":" << port;
 
	delete fServerConnection;
	fServerConnection = NULL;
 
	BNetworkAddress address(server, port);
	if (fUseSSL)
		fServerConnection = new(std::nothrow) BSecureSocket(address);
	else
		fServerConnection = new(std::nothrow) BSocket(address);
 
	status_t status = B_NO_MEMORY;
	if (fServerConnection != NULL)
		status = fServerConnection->InitCheck();
 
	BString line;
	if (status == B_OK) {
		ssize_t length = ReceiveLine(line);
		if (length < 0)
			status = length;
	}
 
	if (status != B_OK) {
		fServerConnection->Disconnect();
		errorMessage << ": " << strerror(status);
		ShowError(errorMessage.String());
		return status;
	}
 
	if (strncmp(line.String(), "+OK", 3) != 0) {
		if (line.Length() > 0) {
			errorMessage << B_TRANSLATE(". The server said:\n")
				<< line.String();
		} else
			errorMessage << B_TRANSLATE(": No reply.\n");
 
		ShowError(errorMessage.String());
		fServerConnection->Disconnect();
		return B_ERROR;
	}
 
	fLog = line;
	return B_OK;
}
 
 
status_t
POP3Protocol::Login(const char* uid, const char* password, int method)
{
	status_t err;
 
	BString errorMessage(B_TRANSLATE("Error while authenticating user %user"));
	errorMessage.ReplaceFirst("%user", uid);
 
	if (method == 1) {	//APOP
		int32 index = fLog.FindFirst("<");
		if(index != B_ERROR) {
			ReportProgress(0, 0, B_TRANSLATE("Sending APOP authentication"
				B_UTF8_ELLIPSIS));
			int32 end = fLog.FindFirst(">", index);
			BString timestamp("");
			fLog.CopyInto(timestamp, index, end - index + 1);
			timestamp += password;
			char md5sum[33];
			MD5Digest((unsigned char*)timestamp.String(), md5sum);
			BString cmd = "APOP ";
			cmd += uid;
			cmd += " ";
			cmd += md5sum;
			cmd += CRLF;
 
			err = SendCommand(cmd.String());
			if (err != B_OK) {
				errorMessage << B_TRANSLATE(". The server said:\n") << fLog;
				ShowError(errorMessage.String());
				return err;
			}
 
			return B_OK;
		} else {
			errorMessage << B_TRANSLATE(": The server does not support APOP.");
			ShowError(errorMessage.String());
			return B_NOT_ALLOWED;
		}
	}
	ReportProgress(0, 0, B_TRANSLATE("Sending username" B_UTF8_ELLIPSIS));
 
	BString cmd = "USER ";
	cmd += uid;
	cmd += CRLF;
 
	err = SendCommand(cmd.String());
	if (err != B_OK) {
		errorMessage << B_TRANSLATE(". The server said:\n") << fLog;
		ShowError(errorMessage.String());
		return err;
	}
 
	ReportProgress(0, 0, B_TRANSLATE("Sending password" B_UTF8_ELLIPSIS));
	cmd = "PASS ";
	cmd += password;
	cmd += CRLF;
 
	err = SendCommand(cmd.String());
	if (err != B_OK) {
		errorMessage << B_TRANSLATE(". The server said:\n") << fLog;
		ShowError(errorMessage.String());
		return err;
	}
 
	return B_OK;
}
 
 
status_t
POP3Protocol::Stat()
{
	ReportProgress(0, 0, B_TRANSLATE("Getting mailbox size" B_UTF8_ELLIPSIS));
 
	if (SendCommand("STAT" CRLF) < B_OK)
		return B_ERROR;
 
	int32 messages;
	int32 dropSize;
	if (sscanf(fLog.String(), "+OK %" B_SCNd32" %" B_SCNd32, &messages,
			&dropSize) < 2)
		return B_ERROR;
 
	fNumMessages = messages;
	fMailDropSize = dropSize;
 
	return B_OK;
}
 
 
int32
POP3Protocol::Messages()
{
	if (fNumMessages < 0)
		Stat();
 
	return fNumMessages;
}
 
 
size_t
POP3Protocol::MailDropSize()
{
	if (fNumMessages < 0)
		Stat();
 
	return fMailDropSize;
}
 
 
void
POP3Protocol::CheckForDeletedMessages()
{
	{
		// Delete things from the manifest no longer on the server
		BStringList list;
		NotHere(fUniqueIDs, fManifest, &list);
		fManifest.Remove(list);
	}
 
	if (!fSettings.FindBool("delete_remote_when_local")
		|| fManifest.CountStrings() == 0)
		return;
 
	BStringList toDelete;
 
	BStringList queryContents;
	BVolumeRoster volumes;
	BVolume volume;
 
	while (volumes.GetNextVolume(&volume) == B_OK) {
		BQuery fido;
		entry_ref entry;
 
		fido.SetVolume(&volume);
		fido.PushAttr(B_MAIL_ATTR_ACCOUNT_ID);
		fido.PushInt32(fAccountSettings.AccountID());
		fido.PushOp(B_EQ);
 
		fido.Fetch();
 
		BString uid;
		while (fido.GetNextRef(&entry) == B_OK) {
			BNode(&entry).ReadAttrString("MAIL:unique_id", &uid);
			queryContents.Add(uid);
		}
	}
	NotHere(queryContents, fManifest, &toDelete);
 
	for (int32 i = 0; i < toDelete.CountStrings(); i++) {
		printf("delete mail on server uid %s\n", toDelete.StringAt(i).String());
		Delete(fUniqueIDs.IndexOf(toDelete.StringAt(i)));
	}
 
	// Don't remove ids from fUniqueIDs, the indices have to stay the same when
	// retrieving new messages.
	fManifest.Remove(toDelete);
 
	// TODO: at some point the purged manifest should be written to disk
	// otherwise it will grow forever
}
 
 
status_t
POP3Protocol::Retrieve(int32 message, BPositionIO* to)
{
	BString cmd;
	cmd << "RETR " << message + 1 << CRLF;
	status_t status = RetrieveInternal(cmd.String(), message, to, true);
	ReportProgress(1, 0);
 
	if (status == B_OK) {
		// Check if the actual message size matches the expected one
		int32 size = MessageSize(message);
 		to->Seek(0, SEEK_END);
		if (to->Position() != size) {
			printf("POP3Protocol::Retrieve Note: message size is %" B_PRIdOFF
				", was expecting %" B_PRId32 ", for message #%" B_PRId32
				".  Could be a transmission error or a bad POP server "
				"implementation (does it remove escape codes when it counts "
				"size?).\n", to->Position(), size, message);
		}
	}
 
	return status;
}
 
 
status_t
POP3Protocol::GetHeader(int32 message, BPositionIO* to)
{
	BString cmd;
	cmd << "TOP " << message + 1 << " 0" << CRLF;
	return RetrieveInternal(cmd.String(), message, to, false);
}
 
 
status_t
POP3Protocol::RetrieveInternal(const char* command, int32 message,
	BPositionIO* to, bool postProgress)
{
	const int bufSize = 1024 * 30;
 
	// To avoid waiting for the non-arrival of the next data packet, try to
	// receive only the message size, plus the 3 extra bytes for the ".\r\n"
	// after the message.  Of course, if we get it wrong (or it is a huge
	// message or has lines starting with escaped periods), it will then switch
	// back to receiving full buffers until the message is done.
	int amountToReceive = MessageSize(message) + 3;
	if (amountToReceive >= bufSize || amountToReceive <= 0)
		amountToReceive = bufSize - 1;
 
	BString bufBString; // Used for auto-dealloc on return feature.
	char* buf = bufBString.LockBuffer(bufSize);
	int amountInBuffer = 0;
	int amountReceived;
	int testIndex;
	char* testStr;
	bool cont = true;
	bool flushWholeBuffer = false;
	to->Seek(0, SEEK_SET);
 
	if (SendCommand(command) != B_OK)
		return B_ERROR;
 
	while (cont) {
		status_t result = fServerConnection->WaitForReadable(
			POP3_RETRIEVAL_TIMEOUT);
		if (result == B_TIMED_OUT) {
			// No data available, even after waiting a minute.
			fLog = "POP3 timeout - no data received after a long wait.";
			return B_TIMED_OUT;
		}
		if (amountToReceive > bufSize - 1 - amountInBuffer)
			amountToReceive = bufSize - 1 - amountInBuffer;
 
		amountReceived = fServerConnection->Read(buf + amountInBuffer,
			amountToReceive);
 
		if (amountReceived < 0) {
			fLog = strerror(amountReceived);
			return amountReceived;
		}
		if (amountReceived == 0) {
			fLog = "POP3 data supposedly ready to receive but not received!";
			return B_ERROR;
		}
 
		amountToReceive = bufSize - 1; // For next time, read a full buffer.
		amountInBuffer += amountReceived;
		buf[amountInBuffer] = 0; // NUL stops tests past the end of buffer.
 
		// Look for lines starting with a period.  A single period by itself on
		// a line "\r\n.\r\n" marks the end of the message (thus the need for
		// at least five characters in the buffer for testing).  A period
		// "\r\n.Stuff" at the start of a line get deleted "\r\nStuff", since
		// POP adds one as an escape code to let you have message text with
		// lines starting with a period.  For convenience, assume that no
		// messages start with a period on the very first line, so we can
		// search for the previous line's "\r\n".
 
		for (testIndex = 0; testIndex <= amountInBuffer - 5; testIndex++) {
			testStr = buf + testIndex;
			if (testStr[0] == '\r' && testStr[1] == '\n' && testStr[2] == '.') {
				if (testStr[3] == '\r' && testStr[4] == '\n') {
					// Found the end of the message marker.
					// Ignore remaining data.
					if (amountInBuffer > testIndex + 5) {
						printf("POP3Protocol::RetrieveInternal Ignoring %d "
							"bytes of extra data past message end.\n",
							amountInBuffer - (testIndex + 5));
					}
					amountInBuffer = testIndex + 2; // Don't include ".\r\n".
					buf[amountInBuffer] = 0;
					cont = false;
				} else {
					// Remove an extra period at the start of a line.
					// Inefficient, but it doesn't happen often that you have a
					// dot starting a line of text.  Of course, a file with a
					// lot of double period lines will get processed very
					// slowly.
					memmove(buf + testIndex + 2, buf + testIndex + 3,
						amountInBuffer - (testIndex + 3) + 1);
					amountInBuffer--;
					// Watch out for the end of buffer case, when the POP text
					// is "\r\n..X".  Don't want to leave the resulting
					// "\r\n.X" in the buffer (flush out the whole buffer),
					// since that will get mistakenly evaluated again in the
					// next loop and delete a character by mistake.
					if (testIndex >= amountInBuffer - 4 && testStr[2] == '.') {
						printf("POP3Protocol::RetrieveInternal: Jackpot!  "
							"You have hit the rare situation with an escaped "
							"period at the end of the buffer.  Aren't you happy"
							"it decodes it correctly?\n");
						flushWholeBuffer = true;
					}
				}
			}
		}
 
		if (cont && !flushWholeBuffer) {
			// Dump out most of the buffer, but leave the last 4 characters for
			// comparison continuity, in case the line starting with a period
			// crosses a buffer boundary.
			if (amountInBuffer > 4) {
				to->Write(buf, amountInBuffer - 4);
				if (postProgress)
					ReportProgress(0, amountInBuffer - 4);
				memmove(buf, buf + amountInBuffer - 4, 4);
				amountInBuffer = 4;
			}
		} else {
			// Dump everything - end of message or flushing the whole buffer.
			to->Write(buf, amountInBuffer);
			if (postProgress)
				ReportProgress(0, amountInBuffer);
			amountInBuffer = 0;
		}
	}
	return B_OK;
}
 
 
void
POP3Protocol::Delete(int32 index)
{
	BString cmd = "DELE ";
	cmd << (index + 1) << CRLF;
	if (SendCommand(cmd.String()) != B_OK) {
		// Error
	}
#if DEBUG
	puts(fLog.String());
#endif
	// The mail is just marked as deleted and removed from the server when
	// sending the QUIT command. Because of that the message number stays
	// the same and we keep the uid in the uid list.
}
 
 
size_t
POP3Protocol::MessageSize(int32 index)
{
	return fSizes[index];
}
 
 
ssize_t
POP3Protocol::ReceiveLine(BString& line)
{
	int32 length = 0;
	bool flag = false;
 
	line = "";
 
	status_t result = fServerConnection->WaitForReadable(
		POP3_RETRIEVAL_TIMEOUT);
	if (result == B_TIMED_OUT)
		return errno;
 
	while (true) {
		// Hope there's an end of line out there else this gets stuck.
		int32 bytesReceived;
		uint8 c = 0;
 
		bytesReceived = fServerConnection->Read((char*)&c, 1);
		if (bytesReceived < 0)
			return bytesReceived;
 
		if (c == '\n' || bytesReceived == 0)
			break;
 
		if (c == '\r') {
			flag = true;
		} else {
			if (flag) {
				length++;
				line += '\r';
				flag = false;
			}
			length++;
			line += (char)c;
		}
	}
 
	return length;
}
 
 
status_t
POP3Protocol::SendCommand(const char* cmd)
{
	// Flush any accumulated garbage data before we send our command, so we
	// don't misinterrpret responses from previous commands (that got left over
	// due to bugs) as being from this command.
	while (fServerConnection->WaitForReadable(1000) == B_OK) {
		char buffer[4096];
		ssize_t amountReceived = fServerConnection->Read(buffer,
			sizeof(buffer) - 1);
		if (amountReceived < 0)
			return amountReceived;
 
		buffer[amountReceived] = 0;
		printf("POP3Protocol::SendCommand Bug! Had to flush %" B_PRIdSSIZE
			" bytes: %s\n", amountReceived, buffer);
	}
 
	if (fServerConnection->Write(cmd, ::strlen(cmd)) < 0) {
		fLog = strerror(errno);
		printf("POP3Protocol::SendCommand Send \"%s\" failed, code %d: %s\n",
			cmd, errno, fLog.String());
		return errno;
	}
 
	fLog = "";
	int32 length = ReceiveLine(fLog);
	if (length <= 0 || fLog.ICompare("+OK", 3) == 0)
		return B_OK;
 
	if (fLog.ICompare("-ERR", 4) == 0) {
		printf("POP3Protocol::SendCommand \"%s\" got error message "
			"from server: %s\n", cmd, fLog.String());
		return B_ERROR;
	}
 
	printf("POP3Protocol::SendCommand \"%s\" got nonsense message "
		"from server: %s\n", cmd, fLog.String());
	return B_BAD_DATA;
		// If it's not +OK, and it's not -ERR, then what the heck
		// is it? Presume an error
}
 
 
void
POP3Protocol::MD5Digest(unsigned char* in, char* asciiDigest)
{
	unsigned char digest[16];
 
	MD5_CTX context;
 
	MD5Init(&context);
	MD5Update(&context, in, ::strlen((char*)in));
	MD5Final(digest, &context);
 
	for (int i = 0;  i < 16;  i++) {
		sprintf(asciiDigest + 2 * i, "%02x", digest[i]);
	}
 
	return;
}
 
 
status_t
POP3Protocol::_RetrieveUniqueIDs()
{
	fUniqueIDs.MakeEmpty();
	fSizes.clear();
	fTotalSize = 0;
 
	status_t status = SendCommand("UIDL" CRLF);
	if (status != B_OK)
		return status;
 
	BString result;
	int32 uidOffset;
	while (ReceiveLine(result) > 0) {
		if (result.ByteAt(0) == '.')
			break;
 
		uidOffset = result.FindFirst(' ') + 1;
		result.Remove(0, uidOffset);
		fUniqueIDs.Add(result);
	}
 
	if (SendCommand("LIST" CRLF) != B_OK)
		return B_ERROR;
 
	while (ReceiveLine(result) > 0) {
		if (result.ByteAt(0) == '.')
			break;
 
		int32 index = result.FindLast(" ");
		int32 size;
		if (index >= 0)
			size = atol(&result.String()[index]);
		else
			size = 0;
 
		fTotalSize += size;
		fSizes.push_back(size);
	}
 
	return B_OK;
}
 
 
void
POP3Protocol::_ReadManifest()
{
	fManifest.MakeEmpty();
	BString attribute = "MAIL:";
	attribute << fAccountSettings.AccountID() << ":manifest";
		// In case someone puts multiple accounts in the same directory
 
	BNode node(fDestinationDir);
	if (node.InitCheck() != B_OK)
		return;
 
	// We already have a directory so we can try to read metadata
	// from it. Note that it is normal for this directory not to
	// be found on the first run as it will be later created by
	// the INBOX system filter.
	attr_info info;
	if (node.GetAttrInfo(attribute.String(), &info) != B_OK || info.size == 0)
		return;
 
	void* flatmanifest = malloc(info.size);
	node.ReadAttr(attribute.String(), fManifest.TypeCode(), 0,
		flatmanifest, info.size);
	fManifest.Unflatten(fManifest.TypeCode(), flatmanifest, info.size);
	free(flatmanifest);
}
 
 
void
POP3Protocol::_WriteManifest()
{
	BString attribute = "MAIL:";
	attribute << fAccountSettings.AccountID() << ":manifest";
		// In case someone puts multiple accounts in the same directory
	BNode node(fDestinationDir);
	if (node.InitCheck() != B_OK) {
		ShowError("Error while saving account manifest: cannot use "
			"destination directory.");
		return;
	}
 
	node.RemoveAttr(attribute.String());
	ssize_t manifestsize = fManifest.FlattenedSize();
	void* flatmanifest = malloc(manifestsize);
	fManifest.Flatten(flatmanifest, manifestsize);
	status_t err = node.WriteAttr(attribute.String(),
		fManifest.TypeCode(), 0, flatmanifest, manifestsize);
	if (err < 0) {
		BString error = "Error while saving account manifest: ";
		error << strerror(err);
			printf("moep error\n");
		ShowError(error.String());
	}
 
	free(flatmanifest);
}
 
 
//	#pragma mark -
 
 
BInboundMailProtocol*
instantiate_inbound_protocol(const BMailAccountSettings& settings)
{
	return new POP3Protocol(settings);
}
 
 
status_t
pop3_smtp_auth(const BMailAccountSettings& settings)
{
	POP3Protocol protocol(settings);
	protocol.Connect();
	protocol.Disconnect();
	return B_OK;
}