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.
591 lines
14 KiB
591 lines
14 KiB
//=============================================================================
|
|
// File: mediatyp.cpp
|
|
// Contents: Definitions for DwMediaType
|
|
// 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 <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <iostream>
|
|
#include <time.h>
|
|
#include <mimelib/string.h>
|
|
#include <mimelib/param.h>
|
|
#include <mimelib/mediatyp.h>
|
|
#include <mimelib/token.h>
|
|
#include <mimelib/utility.h>
|
|
#include <mimelib/enum.h>
|
|
|
|
|
|
const char* const DwMediaType::sClassName = "DwMediaType";
|
|
|
|
|
|
DwMediaType* (*DwMediaType::sNewMediaType)(const DwString&,
|
|
DwMessageComponent*) = 0;
|
|
|
|
|
|
DwMediaType* DwMediaType::NewMediaType(const DwString& aStr,
|
|
DwMessageComponent* aParent)
|
|
{
|
|
if (sNewMediaType) {
|
|
return sNewMediaType(aStr, aParent);
|
|
}
|
|
else {
|
|
return new DwMediaType(aStr, aParent);
|
|
}
|
|
}
|
|
|
|
|
|
DwMediaType::DwMediaType()
|
|
{
|
|
mType = DwMime::kTypeNull;
|
|
mSubtype = DwMime::kSubtypeNull;
|
|
mFirstParameter = 0;
|
|
mClassId = kCidMediaType;
|
|
mClassName = sClassName;
|
|
}
|
|
|
|
|
|
DwMediaType::DwMediaType(const DwMediaType& aCntType)
|
|
: DwFieldBody(aCntType),
|
|
mTypeStr(aCntType.mTypeStr),
|
|
mSubtypeStr(aCntType.mSubtypeStr),
|
|
mBoundaryStr(aCntType.mBoundaryStr)
|
|
{
|
|
mType = aCntType.mType;
|
|
mSubtype = aCntType.mSubtype;
|
|
mFirstParameter = 0;
|
|
|
|
if (aCntType.mFirstParameter) {
|
|
CopyParameterList(aCntType.mFirstParameter);
|
|
}
|
|
|
|
mClassId = kCidMediaType;
|
|
mClassName = sClassName;
|
|
}
|
|
|
|
|
|
DwMediaType::DwMediaType(const DwString& aStr, DwMessageComponent* aParent)
|
|
: DwFieldBody(aStr, aParent)
|
|
{
|
|
mType = DwMime::kTypeNull;
|
|
mSubtype = DwMime::kSubtypeNull;
|
|
mFirstParameter = 0;
|
|
mClassId = kCidMediaType;
|
|
mClassName = sClassName;
|
|
}
|
|
|
|
|
|
DwMediaType::~DwMediaType()
|
|
{
|
|
if (mFirstParameter) {
|
|
DeleteParameterList();
|
|
}
|
|
}
|
|
|
|
|
|
const DwMediaType& DwMediaType::operator = (const DwMediaType& aCntType)
|
|
{
|
|
if (this == &aCntType) return *this;
|
|
DwFieldBody::operator = (aCntType);
|
|
|
|
mType = aCntType.mType;
|
|
mSubtype = aCntType.mSubtype;
|
|
mTypeStr = aCntType.mTypeStr;
|
|
mSubtypeStr = aCntType.mSubtypeStr;
|
|
mBoundaryStr = aCntType.mBoundaryStr;
|
|
|
|
if (mFirstParameter) {
|
|
DeleteParameterList();
|
|
}
|
|
if (aCntType.mFirstParameter) {
|
|
CopyParameterList(aCntType.mFirstParameter);
|
|
}
|
|
|
|
if (mParent) {
|
|
mParent->SetModified();
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
int DwMediaType::Type() const
|
|
{
|
|
return mType;
|
|
}
|
|
|
|
|
|
void DwMediaType::SetType(int aType)
|
|
{
|
|
mType = aType;
|
|
TypeEnumToStr();
|
|
SetModified();
|
|
}
|
|
|
|
|
|
const DwString& DwMediaType::TypeStr() const
|
|
{
|
|
return mTypeStr;
|
|
}
|
|
|
|
|
|
void DwMediaType::SetTypeStr(const DwString& aStr)
|
|
{
|
|
mTypeStr = aStr;
|
|
TypeStrToEnum();
|
|
SetModified();
|
|
}
|
|
|
|
|
|
int DwMediaType::Subtype() const
|
|
{
|
|
return mSubtype;
|
|
}
|
|
|
|
|
|
void DwMediaType::SetSubtype(int aSubtype)
|
|
{
|
|
mSubtype = aSubtype;
|
|
SubtypeEnumToStr();
|
|
SetModified();
|
|
}
|
|
|
|
|
|
const DwString& DwMediaType::SubtypeStr() const
|
|
{
|
|
return mSubtypeStr;
|
|
}
|
|
|
|
|
|
void DwMediaType::SetSubtypeStr(const DwString& aStr)
|
|
{
|
|
mSubtypeStr = aStr;
|
|
SubtypeStrToEnum();
|
|
SetModified();
|
|
}
|
|
|
|
|
|
const DwString& DwMediaType::Boundary() const
|
|
{
|
|
// Implementation note: this member function is const, which
|
|
// forbids us from assigning to mBoundaryStr. The following
|
|
// trick gets around this. (ANSI implementations could use the
|
|
// "mutable" declaration).
|
|
DwMediaType* _this = (DwMediaType*) this;
|
|
_this->mBoundaryStr = "";
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
if (DwStrcasecmp(param->Attribute(), "boundary") == 0) {
|
|
// Boundary parameter found. Return its value.
|
|
_this->mBoundaryStr = param->Value();
|
|
break;
|
|
}
|
|
param = param->Next();
|
|
}
|
|
return mBoundaryStr;
|
|
}
|
|
|
|
|
|
void DwMediaType::SetBoundary(const DwString& aStr)
|
|
{
|
|
mBoundaryStr = aStr;
|
|
// Search for boundary parameter in parameter list. If found, set its
|
|
// value.
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
if (DwStrcasecmp(param->Attribute(), "boundary") == 0) {
|
|
param->SetValue(mBoundaryStr);
|
|
return;
|
|
}
|
|
param = param->Next();
|
|
}
|
|
// Boundary parameter not found. Add it.
|
|
param = DwParameter::NewParameter("", 0);
|
|
param->SetAttribute("boundary");
|
|
param->SetValue(aStr);
|
|
AddParameter(param);
|
|
}
|
|
|
|
|
|
void DwMediaType::CreateBoundary(unsigned aLevel)
|
|
{
|
|
// Create a random printable string and set it as the boundary parameter
|
|
static const char c[] = "ABCDEFGHIJKLMNOPTQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
const int cLen = 64;
|
|
char buf[80];
|
|
strcpy(buf, "Boundary-");
|
|
int pos = strlen(buf);
|
|
int n = aLevel / 10;
|
|
buf[pos++] = (n % 10) + '0';
|
|
n = aLevel;
|
|
buf[pos++] = (n % 10) + '0';
|
|
buf[pos++] = '=';
|
|
buf[pos++] = '_';
|
|
DwUint32 r = (DwUint32) time(0);
|
|
buf[pos++] = c[r % cLen];
|
|
r /= cLen;
|
|
buf[pos++] = c[r % cLen];
|
|
r /= cLen;
|
|
buf[pos++] = c[r % cLen];
|
|
r /= cLen;
|
|
buf[pos++] = c[r % cLen];
|
|
r /= cLen;
|
|
buf[pos++] = c[r % cLen];
|
|
for (int i=0; i < 2; ++i) {
|
|
r = rand();
|
|
buf[pos++] = c[r % cLen];
|
|
r >>= 6;
|
|
buf[pos++] = c[r % cLen];
|
|
r >>= 6;
|
|
buf[pos++] = c[r % cLen];
|
|
r >>= 6;
|
|
buf[pos++] = c[r % cLen];
|
|
r >>= 6;
|
|
buf[pos++] = c[r % cLen];
|
|
}
|
|
buf[pos] = 0;
|
|
SetBoundary(buf);
|
|
}
|
|
|
|
|
|
const DwString& DwMediaType::Name() const
|
|
{
|
|
// Implementation note: this member function is const, which
|
|
// forbids us from assigning to mNameStr. The following
|
|
// trick gets around this. (ANSI implementations could use the
|
|
// "mutable" declaration).
|
|
DwMediaType* _this = (DwMediaType*) this;
|
|
_this->mNameStr = "";
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
if (DwStrcasecmp(param->Attribute(), "name") == 0) {
|
|
// Name parameter found. Return its value.
|
|
_this->mNameStr = param->Value();
|
|
break;
|
|
}
|
|
param = param->Next();
|
|
}
|
|
return mNameStr;
|
|
}
|
|
|
|
|
|
void DwMediaType::SetName(const DwString& aStr)
|
|
{
|
|
mNameStr = aStr;
|
|
// Search for name parameter in parameter list. If found, set its
|
|
// value.
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
if (DwStrcasecmp(param->Attribute(), "name") == 0) {
|
|
param->SetValue(mNameStr);
|
|
return;
|
|
}
|
|
param = param->Next();
|
|
}
|
|
// Name parameter not found. Add it.
|
|
param = DwParameter::NewParameter("", 0);
|
|
param->SetAttribute("name");
|
|
param->SetValue(aStr);
|
|
AddParameter(param);
|
|
}
|
|
|
|
|
|
DwParameter* DwMediaType::FirstParameter() const
|
|
{
|
|
return mFirstParameter;
|
|
}
|
|
|
|
|
|
void DwMediaType::AddParameter(DwParameter* aParam)
|
|
{
|
|
_AddParameter(aParam);
|
|
SetModified();
|
|
}
|
|
|
|
|
|
void DwMediaType::_AddParameter(DwParameter* aParam)
|
|
{
|
|
if (!mFirstParameter) {
|
|
mFirstParameter = aParam;
|
|
}
|
|
else {
|
|
DwParameter* cur = mFirstParameter;
|
|
DwParameter* next = cur->Next();
|
|
while (next) {
|
|
cur = next;
|
|
next = cur->Next();
|
|
}
|
|
cur->SetNext(aParam);
|
|
}
|
|
aParam->SetParent(this);
|
|
}
|
|
|
|
|
|
void DwMediaType::Parse()
|
|
{
|
|
mIsModified = 0;
|
|
mTypeStr = "";
|
|
mSubtypeStr = "";
|
|
mType = DwMime::kTypeNull;
|
|
mSubtype = DwMime::kSubtypeNull;
|
|
if (mFirstParameter) {
|
|
DeleteParameterList();
|
|
}
|
|
if (mString.length() == 0) return;
|
|
DwRfc1521Tokenizer tokenizer(mString);
|
|
|
|
// Get type.
|
|
int found = 0;
|
|
while (!found && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkToken) {
|
|
mTypeStr = tokenizer.Token();
|
|
found = 1;
|
|
}
|
|
++tokenizer;
|
|
}
|
|
// Get '/'
|
|
found = 0;
|
|
while (!found && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkTspecial
|
|
&& tokenizer.Token()[0] == '/') {
|
|
found = 1;
|
|
}
|
|
++tokenizer;
|
|
}
|
|
// Get subtype
|
|
found = 0;
|
|
while (!found && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkToken) {
|
|
mSubtypeStr = tokenizer.Token();
|
|
found = 1;
|
|
}
|
|
++tokenizer;
|
|
}
|
|
// Get parameters
|
|
DwTokenString tokenStr(mString);
|
|
while (1) {
|
|
// Get ';'
|
|
found = 0;
|
|
while (!found && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkTspecial
|
|
&& tokenizer.Token()[0] == ';') {
|
|
found = 1;
|
|
}
|
|
++tokenizer;
|
|
}
|
|
if (tokenizer.Type() == eTkNull) {
|
|
// No more parameters
|
|
break;
|
|
}
|
|
tokenStr.SetFirst(tokenizer);
|
|
// Get attribute
|
|
DwString attrib;
|
|
int attribFound = 0;
|
|
while (!attribFound && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkToken) {
|
|
attrib = tokenizer.Token();
|
|
attribFound = 1;
|
|
}
|
|
++tokenizer;
|
|
}
|
|
// Get '='
|
|
found = 0;
|
|
while (!found && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkTspecial
|
|
&& tokenizer.Token()[0] == '=') {
|
|
found = 1;
|
|
}
|
|
++tokenizer;
|
|
}
|
|
// Get value but do _not_ stop when finding a '/' in it
|
|
int valueFound = 0;
|
|
while (!valueFound && tokenizer.Type() != eTkNull) {
|
|
if (tokenizer.Type() == eTkToken
|
|
|| tokenizer.Type() == eTkQuotedString) {
|
|
++tokenizer;
|
|
if (tokenizer.Type() != eTkTspecial
|
|
|| tokenizer.Token()[0] != '/')
|
|
valueFound = 1;
|
|
}
|
|
else
|
|
++tokenizer;
|
|
}
|
|
if (attribFound && valueFound) {
|
|
tokenStr.ExtendTo(tokenizer);
|
|
DwParameter* param =
|
|
DwParameter::NewParameter(tokenStr.Tokens(), this);
|
|
param->Parse();
|
|
_AddParameter(param);
|
|
}
|
|
}
|
|
TypeStrToEnum();
|
|
SubtypeStrToEnum();
|
|
}
|
|
|
|
|
|
void DwMediaType::Assemble()
|
|
{
|
|
if (!mIsModified) return;
|
|
mString = "";
|
|
if (mTypeStr.length() == 0 || mSubtypeStr.length() == 0)
|
|
return;
|
|
mString += mTypeStr;
|
|
mString += '/';
|
|
mString += mSubtypeStr;
|
|
DwParameter* param = FirstParameter();
|
|
while (param) {
|
|
param->Assemble();
|
|
if (IsFolding()) {
|
|
mString += ";" DW_EOL " ";
|
|
}
|
|
else {
|
|
mString += "; ";
|
|
}
|
|
mString += param->AsString();
|
|
param = param->Next();
|
|
}
|
|
mIsModified = 0;
|
|
}
|
|
|
|
|
|
DwMessageComponent* DwMediaType::Clone() const
|
|
{
|
|
return new DwMediaType(*this);
|
|
}
|
|
|
|
|
|
void DwMediaType::TypeEnumToStr()
|
|
{
|
|
DwTypeEnumToStr(mType, mTypeStr);
|
|
}
|
|
|
|
|
|
void DwMediaType::TypeStrToEnum()
|
|
{
|
|
mType = DwTypeStrToEnum(mTypeStr);
|
|
|
|
}
|
|
|
|
|
|
void DwMediaType::SubtypeEnumToStr()
|
|
{
|
|
DwSubtypeEnumToStr(mSubtype, mSubtypeStr);
|
|
}
|
|
|
|
|
|
void DwMediaType::SubtypeStrToEnum()
|
|
{
|
|
mSubtype = DwSubtypeStrToEnum(mSubtypeStr);
|
|
|
|
}
|
|
|
|
|
|
void DwMediaType::DeleteParameterList()
|
|
{
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
DwParameter* nextParam = param->Next();
|
|
delete param;
|
|
param = nextParam;
|
|
}
|
|
mFirstParameter = 0;
|
|
SetModified();
|
|
}
|
|
|
|
|
|
void DwMediaType::CopyParameterList(DwParameter* aFirst)
|
|
{
|
|
DwParameter* param = aFirst;
|
|
while (param) {
|
|
DwParameter* newParam = (DwParameter*) param->Clone();
|
|
AddParameter(newParam);
|
|
param = param->Next();
|
|
}
|
|
}
|
|
|
|
|
|
#if defined(DW_DEBUG_VERSION)
|
|
void DwMediaType::PrintDebugInfo(std::ostream& aStrm, int aDepth) const
|
|
{
|
|
aStrm <<
|
|
"--------------- Debug info for DwMediaType class ---------------\n";
|
|
_PrintDebugInfo(aStrm);
|
|
int depth = aDepth - 1;
|
|
depth = (depth >= 0) ? depth : 0;
|
|
if (aDepth == 0 || depth > 0) {
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
param->PrintDebugInfo(aStrm, depth);
|
|
param = param->Next();
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
void DwMediaType::PrintDebugInfo(std::ostream& , int ) const {}
|
|
#endif // defined(DW_DEBUG_VERSION)
|
|
|
|
|
|
#if defined(DW_DEBUG_VERSION)
|
|
void DwMediaType::_PrintDebugInfo(std::ostream& aStrm) const
|
|
{
|
|
DwFieldBody::_PrintDebugInfo(aStrm);
|
|
aStrm << "Type: " << mTypeStr << " (" << mType << ")\n";
|
|
aStrm << "Subtype: " << mSubtypeStr << " (" << mSubtype << ")\n";
|
|
aStrm << "Boundary: " << mBoundaryStr << '\n';
|
|
aStrm << "Parameters: ";
|
|
DwParameter* param = mFirstParameter;
|
|
if (param) {
|
|
int count = 0;
|
|
while (param) {
|
|
if (count) aStrm << ' ';
|
|
aStrm << param->ObjectId();
|
|
param = param->Next();
|
|
++count;
|
|
}
|
|
aStrm << '\n';
|
|
}
|
|
else {
|
|
aStrm << "(none)\n";
|
|
}
|
|
}
|
|
#else
|
|
void DwMediaType::_PrintDebugInfo(std::ostream& ) const {}
|
|
#endif // defined(DW_DEBUG_VERSION)
|
|
|
|
|
|
void DwMediaType::CheckInvariants() const
|
|
{
|
|
#if defined(DW_DEBUG_VERSION)
|
|
mTypeStr.CheckInvariants();
|
|
mSubtypeStr.CheckInvariants();
|
|
mBoundaryStr.CheckInvariants();
|
|
DwParameter* param = mFirstParameter;
|
|
while (param) {
|
|
param->CheckInvariants();
|
|
assert((DwMessageComponent*) this == param->Parent());
|
|
param = param->Next();
|
|
}
|
|
#endif // defined(DW_DEBUG_VERSION)
|
|
}
|