You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
515 lines
12 KiB
515 lines
12 KiB
//=============================================================================
|
|
// File: field.cpp
|
|
// Contents: Definitions for DwField
|
|
// Maintainer: Doug Sauder <dwsauder@fwb.gulf.net>
|
|
// WWW: http://www.fwb.gulf.net/~dwsauder/mimepp.html
|
|
//
|
|
// Copyright (c) 1996, 1997 Douglas W. Sauder
|
|
// All rights reserved.
|
|
//
|
|
// IN NO EVENT SHALL DOUGLAS W. SAUDER BE LIABLE TO ANY PARTY FOR DIRECT,
|
|
// INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
|
|
// THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF DOUGLAS W. SAUDER
|
|
// HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// DOUGLAS W. SAUDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
|
|
// NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
|
|
// PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
|
|
// BASIS, AND DOUGLAS W. SAUDER HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
|
|
// SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|
//
|
|
//=============================================================================
|
|
|
|
#define DW_IMPLEMENTATION
|
|
|
|
#include <mimelib/config.h>
|
|
#include <mimelib/debug.h>
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <iostream>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <mimelib/string.h>
|
|
#include <mimelib/field.h>
|
|
#include <mimelib/headers.h>
|
|
#include <mimelib/fieldbdy.h>
|
|
#include <mimelib/datetime.h>
|
|
#include <mimelib/mailbox.h>
|
|
#include <mimelib/mboxlist.h>
|
|
#include <mimelib/address.h>
|
|
#include <mimelib/addrlist.h>
|
|
#include <mimelib/mechansm.h>
|
|
#include <mimelib/mediatyp.h>
|
|
#include <mimelib/msgid.h>
|
|
#include <mimelib/text.h>
|
|
|
|
|
|
class DwFieldParser {
|
|
friend class DwField;
|
|
private:
|
|
DwFieldParser(const DwString&);
|
|
void Parse();
|
|
const DwString mString;
|
|
DwString mName;
|
|
DwString mBody;
|
|
};
|
|
|
|
|
|
DwFieldParser::DwFieldParser(const DwString& aStr)
|
|
: mString(aStr)
|
|
{
|
|
Parse();
|
|
}
|
|
|
|
|
|
void DwFieldParser::Parse()
|
|
{
|
|
const char* buf = mString.data();
|
|
size_t bufEnd = mString.length();
|
|
size_t pos = 0;
|
|
size_t start = 0;
|
|
size_t len = 0;
|
|
// Get field name
|
|
while (pos < bufEnd) {
|
|
if (buf[pos] == ':') {
|
|
break;
|
|
}
|
|
++pos;
|
|
}
|
|
len = pos;
|
|
// Remove any white space at end of field-name
|
|
while (len > 0) {
|
|
int ch = buf[len-1];
|
|
if (ch != ' ' && ch != '\t') break;
|
|
--len;
|
|
}
|
|
mName = mString.substr(start, len);
|
|
if (pos < bufEnd && buf[pos] == ':') {
|
|
++pos;
|
|
}
|
|
// Skip spaces and tabs (but not newline!)
|
|
while (pos < bufEnd) {
|
|
if (buf[pos] != ' ' && buf[pos] != '\t') break;
|
|
++pos;
|
|
}
|
|
start = pos;
|
|
len = 0;
|
|
// Get field body
|
|
while (pos < bufEnd) {
|
|
if (buf[pos] == '\n') {
|
|
// Are we at the end of the string?
|
|
if (pos == bufEnd - 1) {
|
|
++pos;
|
|
break;
|
|
}
|
|
// Is this really the end of the field body, and not just
|
|
// the end of a wrapped line?
|
|
else if (buf[pos+1] != ' ' && buf[pos+1] != '\t') {
|
|
++pos;
|
|
break;
|
|
}
|
|
}
|
|
++pos;
|
|
}
|
|
// Remove white space at end of field-body
|
|
while (pos > start) {
|
|
if (!isspace(buf[pos-1])) break;
|
|
--pos;
|
|
}
|
|
len = pos - start;
|
|
mBody = mString.substr(start, len);
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
|
|
|
|
const char* const DwField::sClassName = "DwField";
|
|
|
|
|
|
DwField* (*DwField::sNewField)(const DwString&, DwMessageComponent*) = 0;
|
|
|
|
|
|
DwFieldBody* (*DwField::sCreateFieldBody)(const DwString&,
|
|
const DwString&, DwMessageComponent*) = 0;
|
|
|
|
|
|
DwField* DwField::NewField(const DwString& aStr, DwMessageComponent* aParent)
|
|
{
|
|
if (sNewField) {
|
|
return sNewField(aStr, aParent);
|
|
}
|
|
else {
|
|
return new DwField(aStr, aParent);
|
|
}
|
|
}
|
|
|
|
|
|
DwField::DwField()
|
|
{
|
|
mNext = 0;
|
|
mFieldBody = 0;
|
|
mClassId = kCidField;
|
|
mClassName = sClassName;
|
|
}
|
|
|
|
|
|
DwField::DwField(const DwField& aField)
|
|
: DwMessageComponent(aField),
|
|
mFieldNameStr(aField.mFieldNameStr),
|
|
mFieldBodyStr(aField.mFieldBodyStr)
|
|
{
|
|
mNext = 0;
|
|
if (aField.mFieldBody) {
|
|
mFieldBody = (DwFieldBody*) aField.mFieldBody->Clone();
|
|
}
|
|
else {
|
|
mFieldBody = 0;
|
|
}
|
|
mClassId = kCidField;
|
|
mClassName = sClassName;
|
|
}
|
|
|
|
|
|
DwField::DwField(const DwString& aStr, DwMessageComponent* aParent)
|
|
: DwMessageComponent(aStr, aParent)
|
|
{
|
|
mNext = 0;
|
|
mFieldBody = 0;
|
|
mClassId = kCidField;
|
|
mClassName = sClassName;
|
|
}
|
|
|
|
|
|
DwField::~DwField()
|
|
{
|
|
if (mFieldBody) {
|
|
delete mFieldBody;
|
|
}
|
|
}
|
|
|
|
|
|
const DwField& DwField::operator = (const DwField& aField)
|
|
{
|
|
if (this == &aField) return *this;
|
|
DwMessageComponent::operator = (aField);
|
|
mFieldNameStr = aField.mFieldNameStr;
|
|
mFieldBodyStr = aField.mFieldBodyStr;
|
|
if (mFieldBody) {
|
|
delete mFieldBody;
|
|
mFieldBody = (DwFieldBody*) aField.mFieldBody->Clone();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
const DwString& DwField::FieldNameStr() const
|
|
{
|
|
return mFieldNameStr;
|
|
}
|
|
|
|
|
|
void DwField::SetFieldNameStr(const DwString& aStr)
|
|
{
|
|
mFieldNameStr = aStr;
|
|
SetModified();
|
|
}
|
|
|
|
|
|
const DwString& DwField::FieldBodyStr() const
|
|
{
|
|
return mFieldBodyStr;
|
|
}
|
|
|
|
|
|
void DwField::SetFieldBodyStr(const DwString& aStr)
|
|
{
|
|
mFieldBodyStr = aStr;
|
|
if (mFieldBody) {
|
|
delete mFieldBody;
|
|
mFieldBody = 0;
|
|
}
|
|
SetModified();
|
|
}
|
|
|
|
|
|
DwFieldBody* DwField::FieldBody() const
|
|
{
|
|
return mFieldBody;
|
|
}
|
|
|
|
|
|
void DwField::SetFieldBody(DwFieldBody* aFieldBody)
|
|
{
|
|
int isModified = 0;
|
|
if (mFieldBody != aFieldBody) {
|
|
isModified = 1;
|
|
}
|
|
mFieldBody = aFieldBody;
|
|
if (mFieldBody) {
|
|
mFieldBody->SetParent(this);
|
|
}
|
|
if (isModified) {
|
|
SetModified();
|
|
}
|
|
}
|
|
|
|
|
|
void DwField::_SetFieldBody(DwFieldBody* aFieldBody)
|
|
{
|
|
mFieldBody = aFieldBody;
|
|
if (mFieldBody) {
|
|
mFieldBody->SetParent(this);
|
|
}
|
|
}
|
|
|
|
|
|
DwField* DwField::Next() const
|
|
{
|
|
return (DwField*) mNext;
|
|
}
|
|
|
|
|
|
void DwField::SetNext(const DwField* aNext)
|
|
{
|
|
mNext = aNext;
|
|
}
|
|
|
|
|
|
void DwField::Parse()
|
|
{
|
|
mIsModified = 0;
|
|
DwFieldParser parser(mString);
|
|
mFieldNameStr = parser.mName;
|
|
mFieldBodyStr = parser.mBody;
|
|
mFieldBody = CreateFieldBody(mFieldNameStr, mFieldBodyStr, this);
|
|
assert(mFieldBody != 0);
|
|
mFieldBody->Parse();
|
|
}
|
|
|
|
|
|
void DwField::Assemble()
|
|
{
|
|
if (!mIsModified) return;
|
|
if (mFieldBody) {
|
|
mFieldBody->Assemble();
|
|
mFieldBodyStr = mFieldBody->AsString();
|
|
}
|
|
mString = "";
|
|
mString += mFieldNameStr;
|
|
mString += ": ";
|
|
mString += mFieldBodyStr;
|
|
mString += DW_EOL;
|
|
mIsModified = 0;
|
|
}
|
|
|
|
|
|
DwMessageComponent* DwField::Clone() const
|
|
{
|
|
return new DwField(*this);
|
|
}
|
|
|
|
|
|
DwFieldBody* DwField::CreateFieldBody(const DwString& aFieldName,
|
|
const DwString& aFieldBody, DwMessageComponent* aParent)
|
|
{
|
|
DwFieldBody* fieldBody;
|
|
if (sCreateFieldBody != 0) {
|
|
fieldBody = sCreateFieldBody(aFieldName, aFieldBody, aParent);
|
|
}
|
|
else {
|
|
fieldBody = _CreateFieldBody(aFieldName, aFieldBody, aParent);
|
|
}
|
|
return fieldBody;
|
|
}
|
|
|
|
|
|
DwFieldBody* DwField::_CreateFieldBody(const DwString& aFieldName,
|
|
const DwString& aFieldBody, DwMessageComponent* aParent)
|
|
{
|
|
enum {
|
|
kAddressList,
|
|
kDispositionType,
|
|
kDateTime,
|
|
kMailbox,
|
|
kMailboxList,
|
|
kMechanism,
|
|
kMediaType,
|
|
kMsgId,
|
|
kText
|
|
} fieldBodyType;
|
|
// Default field type is 'text'
|
|
fieldBodyType = kText;
|
|
int ch = aFieldName[0];
|
|
ch = tolower(ch);
|
|
switch (ch) {
|
|
case 'b':
|
|
if (DwStrcasecmp(aFieldName, "bcc") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
break;
|
|
case 'c':
|
|
if (DwStrcasecmp(aFieldName, "cc") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "content-id") == 0) {
|
|
fieldBodyType = kMsgId;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "content-transfer-encoding") == 0) {
|
|
fieldBodyType = kMechanism;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "content-type") == 0) {
|
|
fieldBodyType = kMediaType;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "content-disposition") == 0) {
|
|
fieldBodyType = kDispositionType;
|
|
}
|
|
break;
|
|
case 'd':
|
|
if (DwStrcasecmp(aFieldName, "date") == 0) {
|
|
fieldBodyType = kDateTime;
|
|
}
|
|
break;
|
|
case 'f':
|
|
if (DwStrcasecmp(aFieldName, "from") == 0) {
|
|
fieldBodyType = kMailboxList;
|
|
}
|
|
break;
|
|
case 'm':
|
|
if (DwStrcasecmp(aFieldName, "message-id") == 0) {
|
|
fieldBodyType = kMsgId;
|
|
}
|
|
break;
|
|
case 'r':
|
|
if (DwStrcasecmp(aFieldName, "reply-to") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-bcc") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-cc") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-date") == 0) {
|
|
fieldBodyType = kDateTime;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-from") == 0) {
|
|
fieldBodyType = kMailboxList;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-message-id") == 0) {
|
|
fieldBodyType = kMsgId;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-reply-to") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "resent-sender") == 0) {
|
|
fieldBodyType = kMailbox;
|
|
}
|
|
else if (DwStrcasecmp(aFieldName, "return-path") == 0) {
|
|
fieldBodyType = kMailbox;
|
|
}
|
|
break;
|
|
case 's':
|
|
if (DwStrcasecmp(aFieldName, "sender") == 0) {
|
|
fieldBodyType = kMailbox;
|
|
}
|
|
break;
|
|
case 't':
|
|
if (DwStrcasecmp(aFieldName, "to") == 0) {
|
|
fieldBodyType = kAddressList;
|
|
}
|
|
break;
|
|
}
|
|
DwFieldBody* fieldBody;
|
|
switch (fieldBodyType) {
|
|
case kAddressList:
|
|
fieldBody = DwAddressList::NewAddressList(aFieldBody, aParent);
|
|
break;
|
|
case kDispositionType:
|
|
fieldBody = DwDispositionType::NewDispositionType(aFieldBody, aParent);
|
|
break;
|
|
case kMediaType:
|
|
fieldBody = DwMediaType::NewMediaType(aFieldBody, aParent);
|
|
break;
|
|
case kMechanism:
|
|
fieldBody = DwMechanism::NewMechanism(aFieldBody, aParent);
|
|
break;
|
|
case kDateTime:
|
|
fieldBody = DwDateTime::NewDateTime(aFieldBody, aParent);
|
|
break;
|
|
case kMailbox:
|
|
fieldBody = DwMailbox::NewMailbox(aFieldBody, aParent);
|
|
break;
|
|
case kMailboxList:
|
|
fieldBody = DwMailboxList::NewMailboxList(aFieldBody, aParent);
|
|
break;
|
|
case kMsgId:
|
|
fieldBody = DwMsgId::NewMsgId(aFieldBody, aParent);
|
|
break;
|
|
case kText:
|
|
default:
|
|
fieldBody = DwText::NewText(aFieldBody, aParent);
|
|
break;
|
|
}
|
|
return fieldBody;
|
|
}
|
|
|
|
|
|
#if defined (DW_DEBUG_VERSION)
|
|
void DwField::PrintDebugInfo(std::ostream& aStrm, int aDepth) const
|
|
{
|
|
aStrm <<
|
|
"----------------- Debug info for DwField class -----------------\n";
|
|
_PrintDebugInfo(aStrm);
|
|
int depth = aDepth - 1;
|
|
depth = (depth >= 0) ? depth : 0;
|
|
if (mFieldBody && (aDepth == 0 || depth > 0)) {
|
|
mFieldBody->PrintDebugInfo(aStrm, depth);
|
|
}
|
|
}
|
|
#else
|
|
void DwField::PrintDebugInfo(std::ostream& , int ) const {}
|
|
#endif // defined (DW_DEBUG_VERSION)
|
|
|
|
|
|
#if defined (DW_DEBUG_VERSION)
|
|
void DwField::_PrintDebugInfo(std::ostream& aStrm) const
|
|
{
|
|
DwMessageComponent::_PrintDebugInfo(aStrm);
|
|
aStrm << "Field name: " << mFieldNameStr << '\n';
|
|
aStrm << "Field body: " << mFieldBodyStr << '\n';
|
|
aStrm << "Field body object:";
|
|
if (mFieldBody) {
|
|
aStrm << mFieldBody->ObjectId() << '\n';
|
|
}
|
|
else {
|
|
aStrm << "(none)\n";
|
|
}
|
|
aStrm << "Next field: ";
|
|
if (mNext) {
|
|
aStrm << mNext->ObjectId() << '\n';
|
|
}
|
|
else {
|
|
aStrm << "(none)\n";
|
|
}
|
|
}
|
|
#else
|
|
void DwField::_PrintDebugInfo(std::ostream& ) const {}
|
|
#endif // defined (DW_DEBUG_VERSION)
|
|
|
|
|
|
void DwField::CheckInvariants() const
|
|
{
|
|
#if defined (DW_DEBUG_VERSION)
|
|
DwMessageComponent::CheckInvariants();
|
|
mFieldNameStr.CheckInvariants();
|
|
mFieldBodyStr.CheckInvariants();
|
|
if (mFieldBody) {
|
|
mFieldBody->CheckInvariants();
|
|
}
|
|
if (mFieldBody) {
|
|
assert((DwMessageComponent*) this == mFieldBody->Parent());
|
|
}
|
|
#endif // defined (DW_DEBUG_VERSION)
|
|
}
|