falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/programs/dtmail/libDtMail/RFC/RFCMessage.C

1713 lines
48 KiB
C
Raw Permalink Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/*
*+SNOTICE
*
*
* $TOG: RFCMessage.C /main/9 1998/04/06 13:29:56 mgreess $
*
* RESTRICTED CONFIDENTIAL INFORMATION:
*
* The information in this document is subject to special
* restrictions in a confidential disclosure agreement bertween
* HP, IBM, Sun, USL, SCO and Univel. Do not distribute this
* document outside HP, IBM, Sun, USL, SCO, or Univel wihtout
* Sun's specific written approval. This documment and all copies
* and derivative works thereof must be returned or destroyed at
* Sun's request.
*
* Copyright 1993 Sun Microsystems, Inc. All rights reserved.
*
*+ENOTICE
*/
#include <EUSCompat.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <DtMail/DtMail.hh>
#include "RFCImpl.hh"
#include <DtMail/Threads.hh>
#include "str_utils.h"
const char * RFCDeleteHeader = "X-Dt-Delete-Time";
static unsigned long RFCMessageSignature = 0xff83421e;
// RFCMessage constructor for alternative message parts
// Arguments:
// error --
// alt_start -- beginning of alternative message (at interpart boundary)
// alt_end -- last byte of alternative message
// Outputs:
// RFCMessage * (with _alternativeMessage == DTM_TRUE) that has a completely
// parsed and setup message with body parts and minimal envelope.
// Description:
// This constructor is used to create a message that is one of possibly
// many alternative messages that are part of a single MIME multipart
// alternative message.
//
RFCMessage::RFCMessage(DtMailEnv & error,
const char * alt_start,
const char * alt_end)
: DtMail::Message(error, NULL), _bp_cache(8), _alt_msg_cache(0)
{
error.clear();
// Initialize objects within RFCMessage structure
//
_object_signature = RFCMessageSignature;
_dirty = 0; // can never be dirty
_alternativeMultipart = DTM_FALSE; // msg does not contain alternatives
_alternativeMessage = DTM_TRUE; // msg is an alternative message
_alternativeValid = DTM_FALSE; // msg is not valid (maybe later)
_msg_start = alt_start;
_msg_end = alt_end;
_msg_buf = NULL;
_body_start = NULL;
// parse the message, creating an envelope to encompass the first headers
// found and setting up the body part boundaries
//
(void) parseMsg(error, (char *) alt_end);
if (error.isSet()) {
return;
}
// parse the message bodies - this constructor is currently only called
// for a MIME multipart alternative message part. If other mail protocols
// are added that have similar functionality, this constructor will have
// to be augmented to take this into consideration
//
parseMIMEBodies(error);
if (error.isSet()) {
return;
}
// it worked!
return;
}
RFCMessage::RFCMessage(DtMailEnv & error, DtMail::MailBox * parent,
const char ** start,
const char * end_of_file)
: DtMail::Message(error, parent), _bp_cache(8), _alt_msg_cache(8)
{
_object_signature = RFCMessageSignature;
error.clear();
if (_parent) {
_session = _parent->session();
}
_dirty = 0;
_alternativeMultipart = DTM_FALSE;
_alternativeMessage = DTM_FALSE;
_alternativeValid = DTM_FALSE;
_msg_start = *start;
*start = parseMsg(error, end_of_file);
// We want to be lazy about parsing the body. Most messages are
// never viewed in a folder. We have already hit the pages once,
// but with MADV_SEQUENTIAL on, they are marked for immediate
// disposal so they may be gone. Of course we are going to slow
// the first display of the message, but odds are that will never
// happen anyway.
//
// There is another reason for delaying the parsing on an MT hot
// platform. We are parsing on a separate thread. If we wait until
// we are asked for information about the bodies to parse them,
// we can get the main thread to do this work. So, we can actually
// get some concurrent parsing to occur.
//
// Conclusion: Lazy is better!
//
return;
}
RFCMessage::RFCMessage(DtMailEnv & error,
DtMail::Session * session,
DtMailObjectSpace space,
void * arg,
DtMailCallback,
void *)
: DtMail::Message(error, NULL), _bp_cache(8), _alt_msg_cache(8)
{
// We do different processing, depending on the space for the
// object.
//
_session = session;
switch (space) {
case DtMailBufferObject:
{
_object_signature = RFCMessageSignature;
error.clear();
_dirty = 0;
_alternativeMultipart = DTM_FALSE;
_alternativeMessage = DTM_FALSE;
_alternativeValid = DTM_FALSE;
_msg_buf = (DtMailBuffer *)arg;
// If the buffer is not null, then we need to parse the
// buffer.
//
if (_msg_buf->size > 0) {
if (hasHeaders((const char *)_msg_buf->buffer, _msg_buf->size) == DTM_FALSE) {
error.setError(DTME_UnknownFormat);
return;
}
_msg_start = (char *)_msg_buf->buffer;
(void) parseMsg(error, (char *)_msg_buf->buffer + _msg_buf->size);
if (error.isSet()) {
return;
}
}
else {
// We need to construct an empty message.
//
_msg_start = _msg_end = _body_start = NULL;
_envelope = new RFCEnvelope(error, this, NULL, 0);
}
}
break;
case DtMailFileObject:
default:
error.setError(DTME_NotSupported);
}
}
RFCMessage::~RFCMessage(void)
{
if (_object_signature == RFCMessageSignature) {
MutexLock lock_scope(_obj_mutex);
_object_signature = 0;
// spin through the body part cache deleting all parts cached.
// If _alternativeMultipart is set, this is the "main message" and
// as such all of the body parts are merely copied from one of the
// underlying alternative messages, so in this case we only delete the
// body part cache and not the contents of the cache, as that will be
// taken care of when the alternative message cache is purged.
//
while (_bp_cache.length()) {
BodyPartCache * bpc = _bp_cache[0];
if (!_alternativeMultipart)
delete bpc->body;
delete bpc;
_bp_cache.remove(0);
}
// spin through the alternative message cache destroying any
// alternative messages which have been built to support a
// multipart alternative message
//
if (_alternativeMultipart == DTM_TRUE)
while (_alt_msg_cache.length()) {
AlternativeMessageCache * amc = _alt_msg_cache[0];
assert(amc != NULL);
assert(amc->amc_msg != NULL);
delete amc->amc_msg;
assert(amc->amc_body != NULL);
delete amc->amc_body;
delete amc;
_alt_msg_cache.remove(0);
}
}
}
void
RFCMessage::toBuffer(DtMailEnv & error, DtMailBuffer & buf)
{
error.clear();
buf.size = _msg_end - _msg_start + 1;
buf.buffer = new char[buf.size];
if (buf.buffer == NULL) {
error.setError(DTME_NoMemory);
return;
}
memcpy(buf.buffer, _msg_start, (size_t) buf.size);
}
const char *
RFCMessage::impl(DtMailEnv & error)
{
// By definition, we are contained within some RFC container. We
// want to make sure we return the exact same string, so just return
// what our containing parent uses for its impl ID string.
//
if (_parent) {
return(_parent->impl(error));
}
return("Internet MIME");
}
DtMail::Envelope *
RFCMessage::getEnvelope(DtMailEnv & error)
{
error.clear();
return(_envelope);
}
int
RFCMessage::getBodyCount(DtMailEnv & error)
{
error.clear();
// We may need to parse the body!
//
if (_bp_cache.length() == 0) {
parseBodies(error);
}
return(_bp_cache.length());
}
DtMail::BodyPart *
RFCMessage::getFirstBodyPart(DtMailEnv & error)
{
error.clear();
// We may need to parse the body!
//
if (_bp_cache.length() == 0 && _msg_start) {
parseBodies(error);
}
if (_bp_cache.length() == 0) {
return(NULL);
}
return(bodyPart(error, 0));
}
DtMail::BodyPart *
RFCMessage::getNextBodyPart(DtMailEnv & error, DtMail::BodyPart * last)
{
error.clear();
int slot = lookupByBody(last);
if (slot < 0 || (slot + 1) >= _bp_cache.length()) {
return(NULL);
}
slot += 1;
return(bodyPart(error, slot));
}
DtMail::BodyPart *
RFCMessage::newBodyPart(DtMailEnv & error, DtMail::BodyPart * after)
{
error.clear();
int slot = -1;
if (after) {
slot = lookupByBody(after);
}
RFCBodyPart * bp = new MIMEBodyPart(error,
this,
NULL,
0,
NULL);
BodyPartCache * bpc = new BodyPartCache;
bpc->body = bp;
bpc->body_start = NULL;
if (slot < 0) {
_bp_cache.append(bpc);
}
else {
_bp_cache.insert(bpc, slot + 1);
}
return(bp);
}
void
RFCMessage::setFlag(DtMailEnv & error, const DtMailMessageState flag)
{
error.clear();
time_t now;
char str_time[20];
switch (flag) {
case DtMailMessageNew:
_envelope->setHeader(error, "Status", DTM_TRUE, "NR");
break;
case DtMailMessageDeletePending:
// Start the delete time out by setting the X-Delete-Time header.
//
now = time(NULL);
sprintf(str_time, "%08lX", (long)now);
_envelope->setHeader(error, RFCDeleteHeader, DTM_TRUE, str_time);
break;
case DtMailMessagePartial:
//
// There is nothing to do for partial. It is already
// marked as partial as it has the Content-Type: message/partial
// header. This case statment exists so that SetFlag will not
// drop into the default 'error' below.
break;
default:
error.setError(DTME_OperationInvalid);
break;
}
return;
}
void
RFCMessage::resetFlag(DtMailEnv & error, const DtMailMessageState flag)
{
error.clear();
switch (flag) {
case DtMailMessageNew:
_envelope->setHeader(error, "Status", DTM_TRUE, "RO");
break;
case DtMailMessageDeletePending:
_envelope->removeHeader(error, RFCDeleteHeader);
break;
case DtMailMessagePartial:
//
// There is nothing to do for partial. It is already
// marked as partial as it has the Content-Type: message/partial
// header. This case statment exists so that resetFlag will not
// drop into the default 'error' below.
//
// You can not 'reset' message partial, you can only
// delete the header.
break;
default:
error.setError(DTME_OperationInvalid);
}
return;
}
DtMailBoolean
RFCMessage::flagIsSet(DtMailEnv & error, const DtMailMessageState flag)
{
DtMailValueSeq value;
DtMailBoolean answer = DTM_FALSE;
switch (flag) {
case DtMailMessageNew:
_envelope->getHeader(error, "Status", DTM_FALSE, value);
if (error.isNotSet()) {
const char * status = *(value[0]);
if (strcasecmp(status, "ro")) {
answer = DTM_TRUE;
}
}
else {
// No Status: means a new message.
error.clear();
answer = DTM_TRUE;
}
break;
case DtMailMessageDeletePending:
_envelope->getHeader(error, RFCDeleteHeader, DTM_FALSE, value);
if (error.isNotSet()) {
answer = DTM_TRUE;
}
else {
error.clear();
}
break;
case DtMailMessageMultipart:
_envelope->getHeader(error, "Content-Type", DTM_FALSE, value);
if (error.isNotSet()) {
const char * type = *(value[0]);
if (strcasecmp(type, "X-Sun-Attachment") == 0 ||
strncasecmp(type, "multipart", 9) == 0) {
answer = DTM_TRUE;
}
}
else {
error.clear();
}
break;
case DtMailMessagePartial:
_envelope->getHeader(error, "Content-Type", DTM_FALSE, value);
if (error.isNotSet()) {
const char * type = *(value[0]);
if (strncasecmp(type, "message/partial", 15) == 0) {
answer = DTM_TRUE;
}
} else {
error.clear();
}
break;
default:
break;
}
error.clear();
return(answer);
}
time_t
RFCMessage::getDeleteTime(DtMailEnv & error)
{
time_t delete_time = 0;
DtMailValueSeq value;
_envelope->getHeader(error, RFCDeleteHeader, DTM_FALSE, value);
if (error.isNotSet()) {
delete_time = (time_t) strtol(*(value[0]), NULL, 16);
}
error.clear();
return(delete_time);
}
void
RFCMessage::markDirty(const int delta)
{
if (_parent) {
((RFCMailBox *)_parent)->markDirty(delta);
}
_dirty += delta;
if (!_dirty) {
_dirty += 1;
}
}
// Function: RFCMessage::fixMessageLocation - return address/length of message
// Description:
// This function is used to obtain an address and length in bytes of a
// message.
// Method:
// If the message is not dirty (e.g. already mapped into memory as one
// contiguous stream of bytes) then simply return its address and length;
// otherwise, must construct the message into a temporary area, the address
// and length of which is then returned.
// Arguments:
// long & msgLen -- (output) length of message in bytes
// int & msgTemporary -- (output) 0 if message resides in previously
// allocated memory (e.g. mapped already),
// != 0 if temporary space allocated to hold
// message, requiring later deallocation
// Returns:
// const char * -> first byte of message
//
void
RFCMessage::fixMessageLocation(char ** msgHeaderStart, long & msgHeaderLen,
char ** msgBodyStart, long &msgBodyLen,
int & msgTemporary, long & msgBodyOffset)
{
if (!_dirty) {
// This is easy as the message is complete as is, simply return
// its current memory location and size in bytes. The message is
// "permanent" in that it does not currently reside in a temporary
// memory address which later has to be deallocated.
//
*msgHeaderStart = (char *)_msg_start;
msgHeaderLen = _body_start - _msg_start;
*msgBodyStart = (char *)_body_start;
msgBodyLen = (_msg_end - _body_start)+1;
msgTemporary = 0;
msgBodyOffset = 0; // no header offset fudge factor
return;
}
// Well, now it gets tricky. The message is not assembled in one
// place in memory, which prevents fixing an address and length
// for it, so we have to force the message to be constructed. This
// is done in a "temporary" memory area which has to be deallocated
// when the message is mapped in from a real file.
//
pinMessageDown(msgHeaderStart, msgHeaderLen, msgBodyStart, msgBodyLen);
msgBodyOffset = msgHeaderLen-(_body_start-_msg_start);
msgTemporary = 1;
return;
}
// Function: RFCMessage::pinMessageDown - fix complete message in memory
// Description:
// This function is used on a "dirty" message to cause a complete
// in memory copy of the message to be created so that it can be
// written out (probably as a result of a mailbox save operation).
// Method:
// Arguments:
// long & msgLen -- (output) length of message in bytes
// long & msgBodyOffset -- (output) +- adjustment (between original message
// and new message) of the first byte at which the
// body of the message begins -- this lets us determine
// the body start in cases where the headers are changed
// without reparsing the message
// Returns:
// const char * -> first byte of message pinned in memory
//
void
RFCMessage::pinMessageDown(char ** msgHeaderStart, long & msgHeaderLen,
char ** msgBodyStart, long &msgBodyLen)
{
// First, determine which write method to use. We have
// 2 choices, Sun V3, and MIME. We will need to compute
// the size of the message, then make another pass to
// actually store the body.
//
DtMailEnv error;
int content_length;
DtMailValueSeq value;
// Compute content length of message
//
_envelope->getHeader(error, "Mime-Version", DTM_FALSE, value);
if (error.isNotSet()) {
content_length = sizeMIMEBodies(error);
}
else {
error.clear();
content_length = sizeV3Bodies(error);
}
content_length = content_length < 0 ? 0 : content_length;
char len_buf[20];
sprintf(len_buf, "%d", content_length);
_envelope->setHeader(error, "Content-Length", DTM_TRUE, len_buf);
// Allocate storage for the headers and write headers into it
//
const size_t maxHeaderLength =
(size_t) ((RFCEnvelope *)_envelope)->headerLength();
const size_t fudgeAtEnd = 102; // two extra \n's at end of msg + slop
size_t msgNewHeaderSize = (maxHeaderLength+fudgeAtEnd);
*msgHeaderStart = (char *)malloc(msgNewHeaderSize);
assert(*msgHeaderStart != NULL);
char * end = ((RFCEnvelope *)_envelope)->writeHeaders(*msgHeaderStart);
end += 1;
*end++ = '\n';
msgHeaderLen = end-*msgHeaderStart;
// Make sure we did not overflow the allocated area
//
assert(msgHeaderLen < msgNewHeaderSize);
// As of this implementation, body parts can never change, so we do not have to
// worry about the body part needing reconstruction
//
*msgBodyStart = (char *)_body_start;
msgBodyLen = (_msg_end - _body_start)+1;
return;
}
void
RFCMessage::adjustMessageLocation(char * oldStart, char * newStart, long newLength, int msgTemporary, long newBodyOffset)
{
MutexLock lock_scope(_obj_mutex);
assert((_dirty && msgTemporary) || (!_dirty && !msgTemporary));
// At this point the message has been mapped into a new location in memory
// Must adjust all pointers to data contained within this message
//
int len = (int) ((_msg_end - _msg_start) + 1 + newBodyOffset);
assert(len == newLength);
_body_start = (_body_start - _msg_start) + newStart + newBodyOffset;
_msg_end = newStart + len - 1;
((RFCEnvelope *)_envelope)->adjustHeaderLocation(newStart, (int)(_body_start-newStart));
int bpMaxSlot = _bp_cache.length();
int bp;
for (bp = 0; bp < bpMaxSlot; bp++) {
char * new_loc = newStart + (_bp_cache[bp]->body_start - _msg_start) + newBodyOffset;
_bp_cache[bp]->body->adjustBodyPartsLocation(new_loc);
_bp_cache[bp]->body_start = new_loc;
}
// If this is the main portion of a multipart alternative message,
// we must handle each alternative and all of the body parts that
// comprise each alternative
//
if (_alternativeMultipart == DTM_TRUE) {
// Multipart Alternative message parent body
// Adjust all of the body parts cached for the alternatives
//
int altCacheMaxSlot = _alt_msg_cache.length();
for (int altCacheSlot = 0; altCacheSlot < altCacheMaxSlot; altCacheSlot++) {
AlternativeMessageCache *amc = _alt_msg_cache[altCacheSlot];
char *altNewStart = (((RFCEnvelope *) amc->amc_msg->_envelope)->headerLocation() - _msg_start) + newStart + newBodyOffset;
int altHeaderLength =
(int) ((RFCEnvelope *) amc->amc_msg->_envelope)->headerLength();
((RFCEnvelope *) amc->amc_msg->_envelope)->adjustHeaderLocation(altNewStart, altHeaderLength);
bpMaxSlot = amc->amc_msg->_bp_cache.length();
for (bp = 0; bp < bpMaxSlot; bp++) {
char *new_loc = newStart + (amc->amc_msg->_bp_cache[bp]->body_start - _msg_start) + newBodyOffset;
amc->amc_msg->_bp_cache[bp]->body->adjustBodyPartsLocation(new_loc);
amc->amc_msg->_bp_cache[bp]->body_start = new_loc;
}
}
}
_msg_start = newStart;
// If this message is "temporary", it was dirty at the time its location
// was fixed, and therefore was placed into an area allocated on the fly.
// Since the message and all associated pointers no longer refer to this
// area, it must be free'd
//
if (msgTemporary)
free(oldStart);
_dirty = 0;
}
void
RFCMessage::unfixMessageLocation(char * msgStart, int msgTemporary)
{
MutexLock lock_scope(_obj_mutex);
// If this message is "temporary", it was dirty at the time its location
// was fixed, and therefore was placed into an area allocated on the fly.
// Unfix is only called if an error has occurred which requires the
// new message to be tossed, so we must free any storage allocated to
// this message by a previous "fixMessageLocation".
//
if (msgTemporary)
free(msgStart);
}
DtMail::BodyPart *
RFCMessage::bodyPart(DtMailEnv & error, const int slot)
{
error.clear();
MutexLock lock_scope(_obj_mutex);
return(_bp_cache[slot]->body);
}
int
RFCMessage::lookupByBody(DtMail::BodyPart * bp)
{
for (int slot = 0; slot < _bp_cache.length(); slot++) {
if (_bp_cache[slot]->body == bp) {
return(slot);
}
}
return(-1);
}
inline const char *
backcrlf(const char * pos)
{
const char * back = pos;
if (*back == '\n') {
back -= 1;
}
if (*back == '\r') {
back -= 1;
}
return(back);
}
const char *
RFCMessage::parseMsg(DtMailEnv & error,
const char * end_of_file)
{
// We need to find the end of the envelope. This is signified by a
// single blank line. This should simply be "\n\n" in the message
// but RFC says parsers should be forgiving so we will tolerate
// "\n<any-white-space>\n"
//
const char *hdr_end;
for (hdr_end = _msg_start; hdr_end <= end_of_file; hdr_end++) {
if (*hdr_end == '\n') {
int blanks_only = 1;
for (const char * blanks = hdr_end + 1;
*blanks != '\n' && blanks <= end_of_file; blanks++) {
if (!isspace((unsigned char)*blanks)) {
blanks_only = 0;
break;
}
}
if (blanks_only) {
// Found the end of the headers.
break;
}
}
}
if (hdr_end > end_of_file) { // Ran off the end.
error.setError(DTME_NotMailBox);
return(end_of_file + 1);
}
// We need to parse the headers now, because they will give us the
// content length, type, and a message id.
//
_envelope = new RFCEnvelope(error, this, _msg_start, hdr_end - _msg_start + 1);
if (error.isSet()) {
// Oops! We need to find the next "From " line if possible to at least
// let the rest of the parsing proceed.
//
const char *next_from;
for (next_from = hdr_end + 1;
next_from <= (end_of_file - 6); next_from++) {
if (strncmp(next_from, "\nFrom ", 6) == 0) {
break;
}
}
const char * new_end;
if (next_from > (end_of_file - 6)) {
new_end = end_of_file + 1;
}
else {
new_end = next_from + 1;
}
return(new_end);
}
// The hdr_end now points at the last newline of the envelope.
// We want the body to start after the next newline, but we must
// be prepared to stop if the end of the file is seen before the
// body start is found, which can happen if the last message in
// the inbox has no contents at all.
//
for (_body_start = hdr_end + 1; _body_start <= end_of_file && *_body_start != '\n'; _body_start++) {
continue;
}
_body_start += 1;
if (_body_start > end_of_file) // past the end??
_body_start = end_of_file; // yes: body starts on last byte
// Need to know where this message ends.
//
const char *messageEnd = findMsgEnd(error, end_of_file);
// Need to guard against the case where the current body begins
// past the "end" of the current message - this can happen if a
// message consists of [this_msg_headers\n][\n][next_msg_headers]
// where there is a zero length (no) body.
//
if (_body_start > _msg_end) // Does body start after last byte in message?
_body_start = _msg_end; // Yes: force body to start at last byte of message
return(messageEnd);
}
// returns -> last byte of current message
//
const char *
RFCMessage::findMsgEnd(DtMailEnv & error, const char * eof)
{
// This function sets "_msg_end" to ( "_body_start" - 1 + length_of_message ).
// This function returns a pointer to the beginning of the next envelope "From " or (eof+1).
// See if we have a content length. If so, then will try it first.
//
long content_length;
error.clear();
_msg_end = _body_start;
DtMailValueSeq value;
_envelope->getHeader(error, "content-length", DTM_FALSE, value);
if (error.isNotSet()) {
content_length = atol(*(value[0]));
// Look forward content_length amount and see if we are at
// the end (but not beyond) of file, or have a "\nFrom ".
// We must be careful here when using content_length as it *may*
// be a really large (bogus) number and the addition of that number
// to the start of the body *may* wrap around the top of the address
// space, thus resulting in a memory access violation.
//
const char * next_msg = _body_start + content_length;
const int contentLengthFudgeFactor = 30; // "From" header min length
if (next_msg < _body_start) // message wrapped address space?
next_msg = eof+contentLengthFudgeFactor+1; // yes: downsize it
// A special case for content-length = 0. Some folders only
// have one new line in this case which will confuse us
// unless we do something special.
//
if (content_length == 0) {
next_msg -= 1;
if (next_msg <= eof && strncmp(next_msg, "\nFrom ", 6) == 0) {
_msg_end = next_msg;
return(next_msg + 1);
}
}
if (next_msg <= (eof - 6) && strncmp(next_msg, "\nFrom ", 6) == 0) {
// It worked!
_msg_end = backcrlf(next_msg);
return(next_msg + 1);
}
// Content length extends beyond the eof!
// Here it becomes tricky (see bug 1204026). We do not want to
// cause the partial receipt of a very large mail message to
// cause other valid mail messages to be "gobbled up" in this
// message; therefore, we apply a small fudge factor rule here.
// If the current end of message is within X bytes (about the
// size of a reasonable "From" header) then we take the current
// end to be fore this message; otherwise, err on the side of
// bursting this message into multiple smaller ones by doing
// the "From" scan dance.
//
if ( (next_msg > eof)
&& (next_msg < eof+contentLengthFudgeFactor) ) {
_msg_end = eof;
return(next_msg);
}
// We need to deal with extraneous white space at the end of
// the file.
//
if (next_msg <= eof) {
const char *white;
for (white = next_msg; white <= eof && isspace((unsigned char)*white);
white++) {
continue;
}
if (white > eof) {
_msg_end = backcrlf(next_msg);
return(eof + 1);
}
// See if we are at a "\nFrom ". If so, consider it a
// case of off by one and just accept it. This will save
// us from scanning the entire message when the content-length
// simply didnt get trailing white space right.
//
if (strncmp(white - 1, "\nFrom ", 6) == 0) {
_msg_end = white - 2;
return(white);
}
}
}
else {
error.clear();
}
// If the message was sent with X-Lines, we can use it to help
// us find the end of the message.
//
value.clear();
_envelope->getHeader(error, "x-lines", DTM_FALSE, value);
if (error.isNotSet()) {
int xlines = (int) atol(*(value[0]));
int lcnt = 0;
for (_msg_end = _body_start; _msg_end <= eof; _msg_end++) {
if (*_msg_end == '\n') {
lcnt += 1;
if (lcnt == xlines) {
break;
}
}
}
}
if (strncmp(_msg_end, "\nFrom ", 6) != 0) {
// Well, looks like we have to do it the costly way. Scan the
// folder until we hit the end of file, or we hit a "From " at
// the start of a line.
//
for (_msg_end = _body_start - 1; _msg_end <= (eof - 6); _msg_end++) {
if (strncmp(_msg_end, "\nFrom ", 6) == 0) {
break;
}
}
}
// The end is either the eof, or the from line.
//
const char * real_end = _msg_end + 1;
if (_msg_end > (eof - 6)) {
real_end = eof + 1;
_msg_end = eof;
}
else {
// Again, protect against NULL messages with 1 blank line
// before next message. Size was < 0 and crashed in "memcpy".
if ( _msg_end >= _body_start )
_msg_end = backcrlf(_msg_end);
}
// Let's put a content length on this thing so we won't have to go
// through this silliness again!
//
content_length = _msg_end - _body_start + 1;
content_length = content_length < 0 ? 0 : content_length;
char buf[20];
sprintf(buf, "%lu", content_length);
_envelope->setHeader(error, "Content-Length", DTM_TRUE, buf);
return(real_end);
}
// This is a list of all of the Sun V3 specific headers
//
static const char *SCANLIST[] = {
"x-sun-charset",
"x-sun-content-length",
"x-sun-content-lines",
"x-sun-data-description",
"x-sun-data-file",
"x-sun-data-name",
"x-sun-data-type",
"x-sun-encoding-info",
"x-sun-reference-file",
"x-sun-text-type",
(const char *)0};
void
RFCMessage::parseBodies(DtMailEnv & error)
{
error.clear();
// First we need to determine which type of message bodies we
// have. There are actually 3 possibilities: single body part,
// Sun V3, or MIME. The main difference in the last 2 is the
// headers and delimiters used.
//
DtMailValueSeq value;
_envelope->getHeader(error, "Mime-Version", DTM_FALSE, value);
if (error.isNotSet()) {
parseMIMEBodies(error);
}
else {
error.clear();
// We need to try a common MIME header to see if maybe the
// message is just poorly formed. We will examine the content
// type to see if smells like a MIME type.
//
value.clear();
_envelope->getHeader(error, "Content-Type", DTM_FALSE, value);
if (error.isSet()) {
// No content-type or Mime-Version header: treat as V3
//
error.clear();
parseV3Bodies(error);
}
else {
const char * content_type = *(value[0]);
// Handle "Content-Type: text" problem with /usr/lib/mail.local:
// Apparently /usr/lib/mail.local will insert a "Content-Type: text"
// header into received mail if no other Content-Type field is present.
// The format of this header is consistent with RFC 1049 (March 1988)
// which has since been superceeded by the MIME RFC 1521.
//
if (strpbrk(content_type, "/;")) {
// sub-types identify this as MIME formatted e-mail
//
parseMIMEBodies(error);
}
else if (strcasecmp(content_type, "text")==0) {
// Problem time - no Mime-Version is present yet there is a
// content-type: text which means it could either be a Sun V3 OR
// a very poorly formatted MIME message: see if any V3 message
// headers are found and if so treat as V3 else treat as MIME
//
const char **cp;
for (cp = SCANLIST; *cp; cp++) {
_envelope->getHeader(error, *cp, DTM_FALSE, value);
if (error.isNotSet())
break;
error.clear();
}
if (*cp) {
// Found v3 header - treat as such
//
parseV3Bodies(error);
}
else {
// No v3 headers found - treat as MIME
//
parseMIMEBodies(error);
}
}
else {
parseV3Bodies(error);
}
}
}
return;
}
void
RFCMessage::parseMIMEBodies(DtMailEnv & error)
{
error.clear();
// MIME messages have many different forms, all of which we have to
// take into account when parsing the bodies. If there is *no* MIME
// Content-Type field, then we treat the entire body of the message
// as a single body part of Content-Type: text/plain.
//
DtMailValueSeq value;
_envelope->getHeader(error, "Content-Type", DTM_FALSE, value);
if (error.isSet()) {
parseMIMETextPlain(error);
return;
}
// We have a MIME Content-Type field - handle the field appropriately
const char * content_type = *(value[0]);
if (strncasecmp(content_type, "multipart/", 10) == 0)
parseMIMEMultipartSubtype(error, content_type+9);
else if (strncasecmp(content_type, "message/", 8) == 0)
parseMIMEMessageSubtype(error, content_type+7);
else // Unknown MIME Content-Type field - handle as text/plain.
parseMIMETextPlain(error);
return;
}
// parseMIMEMultipartSubtype -- parse a MIME Multipart content-type
// Arguments:
// error --
// subtype -- -> Multipart subtype string (begining with "/")
// Outputs:
// Handle the parsing of the MIME Multipart content-type message according
// to the Multipart sub-type.
// Returns:
// <<none>>
// Description:
// Call this function to handle the parsing of a MIME Multipart subtype.
//
void
RFCMessage::parseMIMEMultipartSubtype(DtMailEnv & error,
const char * subtype)
{
// Have a multipart message to digest - determine type of multipart message
//
const char * boundary = (const char *) extractBoundary(subtype);
if (!boundary) {
// odd--there is no boundary in the multipart/ specification?
// This is specifically required as per RFC 1521:
// The only mandatory parameter for the multipart Content-Type is
// the boundary parameter.
// Treat as one big unbounded message message.
//
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new MIMEBodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
if (strncasecmp(subtype, "/alternative", 12)==0)
parseMIMEMultipartAlternative(error, boundary);
else if (strncasecmp(subtype, "/mixed", 6)==0)
parseMIMEMultipartMixed(error, boundary);
else // unknown types handled as Multipart/mixed
parseMIMEMultipartMixed(error, boundary);
assert(boundary != NULL);
free((void *)boundary);
return;
}
// parseMIMEMessageExternalBody -- parse a MIME Message/External-body message
// Arguments:
// error --
// Outputs:
// Process a MIME Message/External-body message
// Returns:
// <<none>>
// Description:
// Call this function to handle a MIME Message/External-body message
//
void
RFCMessage::parseMIMEMessageExternalBody(DtMailEnv & error)
{
// Have a Message/External-Body message to digest - real dumb here,
// include entire message including the headers as a single text/plain
//
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _msg_start;
bpc->body = new MIMEBodyPart(error, this, _msg_start,
_msg_end - _msg_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
// parseMIMEMessageSubtype -- parse a MIME Message content-type
// Arguments:
// error --
// subtype -- -> Message subtype string (begining with "/")
// Outputs:
// Handle the parsing of the MIME Message content-type message according
// to the Message sub-type.
// Returns:
// <<none>>
// Description:
// Call this function to handle the parsing of a MIME Message subtype.
//
void
RFCMessage::parseMIMEMessageSubtype(DtMailEnv & error,
const char * subtype)
{
// Have a Message message to digest - determine type of Message message
//
if (strncasecmp(subtype, "/external-body", 14) == 0)
parseMIMEMessageExternalBody(error);
else
parseMIMETextPlain(error);
return;
}
// parseMIMETextPlain -- parse a MIME Text/Plain message
// Arguments:
// error --
// Outputs:
// Construct single body part cache component encompassing the entire body
// of the message as defined by _body_start for (_msg_end-_body_start)+1 bytes
// Returns:
// <<none>>
// Description:
// Call this function to take the current message body and treat it as
// a single message of type text/plain.
//
void
RFCMessage::parseMIMETextPlain(DtMailEnv & error)
{
error.clear();
// This is a single body part of text/plain.
//
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new MIMEBodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
// parseMIMEMultipartAlternative -- parse a MIME multipart/alternative message
// Arguments:
// error --
// boundary -- interpart boundary
// Outputs:
// updated message pointers, constructed body part cache, and
// constructed alternative message cache
// Returns:
// <<none>>
// Description:
// Given a multipart alternative MIME message, parse the message, creating
// a body part cache with an entry containing each body part, and ???GMG???
//
// Here is how a multipart alternative message will be parsed into memory,
// where alternatives 1 and 2 can be displayed / processed on this system,
// but alternative 3 can not.
//
// +--------------------+ -> A
// | headers |
// +--------------------+ -> B
// | interpart boundary |
// +--------------------+ -> C
// | alternative 1 |
// +--------------------+ -> D
// | interpart boundary |
// +--------------------+ -> E
// | alternative 2 |
// +--------------------+ -> F
// | interpart boundary |
// +--------------------+ -> G
// | alternative 3 |
// +--------------------+ -> H
// _alternativeMultipart == DTM_TRUE
// _alternativeMessage == DTM_FALSE
// _alternativeValid == DTM_FALSE
// _bp_cache = contents of alternative 2's bp_cache (because 1-2 valid, 3 not)
// _alt_msg_cache = entries for alternative 1, alternative 2, alternative 3
//
// +----------------------+ -> C
// | headers |
// +----------------------+
// | multipart boundary |
// +----------------------+
// | alternative 1 part a |
// +----------------------+
// | multipart boundary |
// +----------------------+
// | alternative 1 part b |
// +----------------------+ -> D
// _alternativeMultipart == DTM_FALSE
// _alternativeMessage == DTM_TRUE
// _alternativeValid == DTM_TRUE [this sample case can display this alt.]
// _bp_cache = entries for part a and part b
// _alt_msg_cache = empty
//
// +----------------------+ -> E
// | headers |
// +----------------------+
// | multipart boundary |
// +----------------------+
// | alternative 2 part a |
// +----------------------+
// | multipart boundary |
// +----------------------+
// | alternative 2 part b |
// +----------------------+ -> F
// _alternativeMultipart == DTM_FALSE
// _alternativeMessage == DTM_TRUE
// _alternativeValid == DTM_TRUE [this sample case can display this alt.]
// _bp_cache = entries for part a and part b
// _alt_msg_cache = empty
//
// +----------------------+ -> G
// | headers |
// +----------------------+
// | multipart boundary |
// +----------------------+
// | alternative 3 part a |
// +----------------------+
// | multipart boundary |
// +----------------------+
// | alternative 3 part b |
// +----------------------+ -> H
// _alternativeMultipart == DTM_FALSE
// _alternativeMessage == DTM_TRUE
// _alternativeValid == DTM_FALSE [this sample case can NOT display this alt.]
// _bp_cache = entries for part a and part b
// _alt_msg_cache = empty
//
void
RFCMessage::parseMIMEMultipartAlternative(DtMailEnv & error, const char * boundary)
{
assert(_alternativeMessage == DTM_FALSE);
assert(boundary != NULL);
// Chew through anything that appears before the first boundary.
//
const char * body = _body_start;
const char * body_end = _msg_end;
int bndry_len = strlen(boundary);
for (; body <= _msg_end; body++) {
if (*body == '-' &&
*(body + 1) == '-' &&
strncmp(body + 2, boundary, bndry_len) == 0) {
break;
}
}
if (body > _msg_end ||
*(body + bndry_len + 2) == '-') {
// No boundaries. Treat as one big message.
//
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new MIMEBodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
// We are sitting at the beginning of the first boundary
// Construct an alternative message cache for the various alternative bodies
// On input to this loop,
// body -> first byte of body part including boundary
// body_end -> end of message (_msg_end)
// On each iteration through the loop,
// - MIMEBodyPart is called with a body boundary of [body]...[body_end]
// - MIMEBodyPart alters body_end to be the last byte of the message,
// containing the boundary *only if* it is the last body part
//
do {
AlternativeMessageCache * amc = new AlternativeMessageCache;
amc->amc_body_start = body;
amc->amc_body_end = body_end;
amc->amc_body = new MIMEBodyPart(error, this, body, &amc->amc_body_end, boundary);
body = amc->amc_body_end;
if ( (amc->amc_body_end == (body_end+1))
&& (strncmp(amc->amc_body_end-(bndry_len+3), boundary, bndry_len) == 0) ){
amc->amc_body_end -= bndry_len+5;
}
amc->amc_msg = new RFCMessage(error, amc->amc_body_start, amc->amc_body_end);
_alt_msg_cache.append(amc);
} while (body <= _msg_end);
// Now we *should* go through the entire alternative message cache validating
// each message to see if it can be displayed on this system. This is a task
// left for a future exercise. For now, use the first alternative always.
//
AlternativeMessageCache *amc = _alt_msg_cache[_alt_msg_cache.length()-1];
int slotMax = amc->amc_msg->_bp_cache.length();
for (int slot = 0; slot < slotMax; slot++) {
BodyPartCache * p_bpc = new BodyPartCache;
BodyPartCache * c_bpc = amc->amc_msg->_bp_cache[slot];
p_bpc->body = c_bpc->body;
p_bpc->body_start = c_bpc->body_start;
_bp_cache.append(p_bpc);
}
_alternativeMultipart = DTM_TRUE; // main msg of multipart alternative
}
// parseMIMEMultipartMixed -- parse a MIME multipart/mixed message
// Arguments:
// error --
// boundary -- bodypart boundary
// Outputs:
// updated message pointers and constructed body part cache
// Returns:
// <<none>>
// Description:
// Given a multipart mixed MIME message, parse the message, creating a body
// part cache with an entry containing each body part.
//
void
RFCMessage::parseMIMEMultipartMixed(DtMailEnv & error, const char * boundary)
{
assert(boundary != NULL);
// Chew through anything that appears before the first boundary.
//
const char * body = _body_start;
const char * body_end = _msg_end;
int bndry_len = strlen(boundary);
for (; body <= _msg_end; body++) {
if (*body == '-' &&
*(body + 1) == '-' &&
strncmp(body + 2, boundary, bndry_len) == 0) {
break;
}
}
if (body > _msg_end ||
*(body + bndry_len + 2) == '-') {
// No boundaries. Treat as one big message.
//
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new MIMEBodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
// We are sitting at the beginning of the first boundary
// Construct a body part cache from the various body parts
// On input to this loop,
// body -> first byte of body part (including boundary)
// body_end -> end of message (_msg_end)
// On each iteration through the loop,
// - MIMEBodyPart is called with a body boundary of [body]...[body_end]
// - MIMEBodyPart alters body_end to be the last byte of the message,
// containing the boundary *only if* it is the last body part
//
do {
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = body;
bpc->body = new MIMEBodyPart(error, this, body, &body_end, boundary);
_bp_cache.append(bpc);
body = body_end;
body_end = _msg_end;
} while (body <= _msg_end);
return;
}
void
RFCMessage::parseV3Bodies(DtMailEnv & error)
{
error.clear();
// We have 3 choices here. We may have no content-type field,
// in which case it is a simple RFC822 message. We handle those
// in the V3 body code because this is really the legacy branch.
//
// We can have a content-type = text which is a single body part
// of either 7 bit text, or 8 bit unencoded text.
//
// Finally we could have a Sun V3 multipart document.
//
DtMailValueSeq value;
_envelope->getHeader(error, "Content-Type", DTM_FALSE, value);
if (error.isSet()) {
// Pretty simple. Pass the entire body and the envelope to
// the V3 body constructor.
//
error.clear();
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new V3BodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
const char * content_type = *(value[0]);
// If the type is text, or, if it isn't an attachment type we
// understand treat the body as a single part.
//
if (strcasecmp(content_type, "text") == 0 ||
strcasecmp(content_type, "x-sun-attachment") != 0) {
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new V3BodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
}
else {
// We need to scan for each of the message boundaries and
// let the body part object parse the important stuff.
//
// V3 bodies start with a sequence of 10 dashes. After that,
// there *should* be a newline. After such a sequence,
// the body part constructor will give us the body end.
//
const char *body;
for (body = _body_start - 1; body <= _msg_end; body++) {
if (*body == '\n' &&
strncmp(body + 1, "----------", 10) == 0 &&
(*(body + 11) == '\n' ||
*(body + 11) == '\r' && *(body + 12) == '\n')) {
break;
}
}
if (body > _msg_end) {
// Well, we have some kind of inconsistency here. Let's
// treat it as one big body part so we can display something.
//
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = _body_start;
bpc->body = new V3BodyPart(error, this, _body_start,
_msg_end - _body_start + 1,
(RFCEnvelope *)_envelope);
_bp_cache.append(bpc);
return;
}
body += 1;
const char * body_end = _msg_end;
do {
BodyPartCache * bpc = new BodyPartCache;
bpc->body_start = body;
bpc->body = new V3BodyPart(error, this, body, &body_end);
_bp_cache.append(bpc);
body = body_end;
body_end = _msg_end;
} while (body <= _msg_end);
}
return;
}
int
RFCMessage::sizeMIMEBodies(DtMailEnv &)
{
// We will use _msg_end - _body_start because this is
// both the correct body length, and the one we updated.
//
return(_msg_end - _body_start + 1);
}
int
RFCMessage::sizeV3Bodies(DtMailEnv &)
{
// We will use _msg_end - _body_start because this is
// both the correct body length, and the one we updated.
//
return(_msg_end - _body_start + 1);
}
char *
RFCMessage::extractBoundary(const char * content_type)
{
const char * boundary;
if (!content_type) {
char * new_bdry = (char *)malloc(78);
sprintf(new_bdry, "%p-%08lx-%p", new_bdry, (long)time(NULL), &new_bdry);
}
// We will need the boundary to find the message boundaries.
//
for (boundary = content_type; *boundary; boundary++) {
if (strncasecmp(boundary, "boundary=", 9) == 0) {
break;
}
}
if (!*boundary) {
return(NULL);
}
// Get past uninteresting cruft.
//
boundary += 9;
int quoted = 0;
if (*boundary == '"') {
boundary += 1;
quoted = 1;
}
// Find the end of the boundary. This will be either the end of
// the line, a quote, or a semi-colon.
//
const char *b_end;
for (b_end = boundary; *b_end; b_end++) {
if (quoted) {
if (*b_end == '"') {
break;
}
}
else {
if (*b_end == ';' || *b_end == '\r' || *b_end == '\n') {
break;
}
}
}
int len = b_end - boundary + 1;
char * result = (char *)malloc(len);
strncpy(result, boundary, len - 1);
result[len - 1] = 0;
return(result);
}
DtMailBoolean
RFCMessage::hasHeaders(const char * buf, const unsigned long len)
{
const char * start = buf;
if (len > 5 && strncmp(buf, "From ", 5) == 0) {
// Get past this line. Unix from line. It doesnt count as
// a header for our purposes.
//
while (start < (buf + len) && *start != '\n') {
start++;
}
start += 1;
if (start >= (buf + len)) {
return(DTM_FALSE);
}
}
// At this point we should have something that looks like a header.
// This will be a string with no spaces, terminated with a colon,
// followed by some text.
//
const char *colon;
for (colon = start; colon < (buf + len) && *colon != ':'; colon++) {
continue;
}
if (colon >= (buf + len) || *colon != ':') {
return(DTM_FALSE);
}
// RFC822 states:
// Once a field has been unfolded, it may be viewed as being com-
// posed of a field-name followed by a colon (":"), followed by a
// field-body, and terminated by a carriage-return/line-feed.
// The field-name must be composed of printable ASCII characters
// (i.e., characters that have values between 33. and 126.,
// decimal, except colon).
//
// We should only find characters between 33 and 126 from the start
// to the colon. Any exception means this is not a valid field-name,
// and therefore, not a valid RFC822 header.
//
for (const char * check = start; check < colon; check++) {
if (*check < 33 || *check > 126) {
return(DTM_FALSE);
}
}
// We passed the criteria, so this must be a header.
//
return(DTM_TRUE);
}
Reference in New Issue View Git Blame Copy Permalink