haiku.git

/*
 * Copyright 2007-2011, Haiku, Inc. All rights reserved.
 * Copyright 2001 Dr. Zoidberg Enterprises. All rights reserved.
 */


/*!
	Glue code for reading/writing messages directly from the protocols but
	present a BPositionIO interface to the caller, while caching the data
	read/written in a slave file.
*/


#include "MessageIO.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


BMailMessageIO::BMailMessageIO(POP3Protocol* protocol, BPositionIO* dumpTo,
	int32 messageID)
	:
	fSlave(dumpTo),
	fMessageID(messageID),
	fProtocol(protocol),
	fSize(0),
	fState(READ_HEADER_NEXT)
{
}


BMailMessageIO::~BMailMessageIO()
{
}


ssize_t
BMailMessageIO::ReadAt(off_t pos, void* buffer, size_t amountToRead)
{
	char lastBytes[5];
	off_t oldPosition = fSlave->Position();

	while (pos + amountToRead > fSize) {
		if (fState >= ALL_READING_DONE)
			break;

		switch (fState) {
			// Read (download from the mail server) just the message headers,
			// and append a blank line if needed (so the header processing code
			// can tell where the end of the headers is).  Don't append too
			// much otherwise the part after the header will appear mangled
			// when it is overwritten in a full read.  This can be useful for
			// filters which discard the message after only reading the header,
			// thus avoiding the time it takes to download the whole message.
			case READ_HEADER_NEXT:
			{
				fSlave->SetSize(0); // Truncate the file.
				fSlave->Seek(0,SEEK_SET);
				status_t status = fProtocol->GetHeader(fMessageID, fSlave);
				if (status != B_OK)
					return status;
				// See if it already ends in a blank line, if not, add enough
				// end-of-lines to give a blank line.
				fSlave->Seek(-4, SEEK_END);
				strcpy(lastBytes, "xxxx");
				fSlave->Read(lastBytes, 4);

				if (strcmp(lastBytes, "\r\n\r\n") != 0) {
					if (strcmp(lastBytes + 2, "\r\n") == 0)
						fSlave->Write("\r\n", 2);
					else
						fSlave->Write("\r\n\r\n", 4);
				}
				fState = READ_BODY_NEXT;
				break;
			}

			// OK, they want more than the headers.  Read the whole message,
			// starting from the beginning (network->Retrieve does a seek to
			// the start of the file for POP3 so we have to read the whole
			// thing).  This wastes a slight amount of time on high speed
			// connections, and on dial-up modem connections, hopefully the
			// modem's V.90 data compression will make it very quick to
			// retransmit the header portion.
			case READ_BODY_NEXT:
			{
				fSlave->SetSize(0); // Truncate the file.
				fSlave->Seek(0,SEEK_SET);
				status_t status = fProtocol->Retrieve(fMessageID, fSlave);
				if (status < 0)
					return status;
				fState = ALL_READING_DONE;
				break;
			}

			default: // Shouldn't happen.
				return -1;
		}
		_ResetSize();
	}

	// Put the file position back at where it was, if possible.  That's because
	// ReadAt isn't supposed to affect the file position.
	if (oldPosition < (off_t)fSize)
		fSlave->Seek (oldPosition, SEEK_SET);
	else
		fSlave->Seek (0, SEEK_END);

	return fSlave->ReadAt(pos, buffer, amountToRead);
}


ssize_t
BMailMessageIO::WriteAt(off_t pos, const void* buffer, size_t amountToWrite)
{
	ssize_t bytesWritten = fSlave->WriteAt(pos, buffer, amountToWrite);
	_ResetSize();

	return bytesWritten;
}


off_t
BMailMessageIO::Seek(off_t position, uint32 seekMode)
{
	if (seekMode == SEEK_END && fState != ALL_READING_DONE) {
		// Force it to read the whole message to find the size of it.
		char tempBuffer;
		fState = READ_BODY_NEXT;
			// Skip the header reading step.
		ssize_t bytesRead = ReadAt(fSize + 1, &tempBuffer, sizeof(tempBuffer));
		if (bytesRead < 0)
			return bytesRead;
	}
	return fSlave->Seek(position, seekMode);
}


off_t
BMailMessageIO::Position() const
{
	return fSlave->Position();
}


void
BMailMessageIO::_ResetSize()
{
	off_t old = fSlave->Position();

	fSlave->Seek(0,SEEK_END);
	fSize = fSlave->Position();

	fSlave->Seek(old,SEEK_SET);
}