llmime.cpp

Go to the documentation of this file.

#include "linden_common.h"
#include "llmime.h"

#include <vector>

#include "llmemorystream.h"

// Headers specified in rfc-2045 will be canonicalized below.
static const std::string CONTENT_LENGTH("Content-Length");
static const std::string CONTENT_TYPE("Content-Type");
static const S32 KNOWN_HEADER_COUNT = 6;
static const std::string KNOWN_HEADER[KNOWN_HEADER_COUNT] =
{
        CONTENT_LENGTH,
        CONTENT_TYPE,
        std::string("MIME-Version"),
        std::string("Content-Transfer-Encoding"),
        std::string("Content-ID"),
        std::string("Content-Description"),
};

// parser helpers
static const std::string MULTIPART("multipart");
static const std::string BOUNDARY("boundary");
static const std::string END_OF_CONTENT_PARAMETER("\r\n ;\t");
static const std::string SEPARATOR_PREFIX("--");
//static const std::string SEPARATOR_SUFFIX("\r\n");

/*
Content-Type: multipart/mixed; boundary="segment"
Content-Length: 24832

--segment
Content-Type: image/j2c
Content-Length: 23715

<data>

--segment
Content-Type: text/xml; charset=UTF-8

<meta data>
EOF

*/

class LLMimeIndex::Impl
{
public:
        Impl() : mOffset(-1), mUseCount(1)
        {}
        Impl(LLSD headers, S32 offset) :
                mHeaders(headers), mOffset(offset), mUseCount(1)
        {}
public:
        LLSD mHeaders;
        S32 mOffset;
        S32 mUseCount;

        typedef std::vector<LLMimeIndex> sub_part_t;
        sub_part_t mAttachments;
};

LLSD LLMimeIndex::headers() const
{
        return mImpl->mHeaders;
}

S32 LLMimeIndex::offset() const
{
        return mImpl->mOffset;
}

S32 LLMimeIndex::contentLength() const
{
        // Find the content length in the headers.
        S32 length = -1;
        LLSD content_length = mImpl->mHeaders[CONTENT_LENGTH];
        if(content_length.isDefined())
        {
                length = content_length.asInteger();
        }
        return length;
}

std::string LLMimeIndex::contentType() const
{
        std::string type;
        LLSD content_type = mImpl->mHeaders[CONTENT_TYPE];
        if(content_type.isDefined())
        {
                type = content_type.asString();
        }
        return type;
}

bool LLMimeIndex::isMultipart() const
{
        bool multipart = false;
        LLSD content_type = mImpl->mHeaders[CONTENT_TYPE];
        if(content_type.isDefined())
        {
                std::string type = content_type.asString();
                int comp = type.compare(0, MULTIPART.size(), MULTIPART);
                if(0 == comp)
                {
                        multipart = true;
                }
        }
        return multipart;
}

S32 LLMimeIndex::subPartCount() const
{
        return mImpl->mAttachments.size();
}

LLMimeIndex LLMimeIndex::subPart(S32 index) const
{
        LLMimeIndex part;
        if((index >= 0) && (index < (S32)mImpl->mAttachments.size()))
        {
                part = mImpl->mAttachments[index];
        }
        return part;
}

LLMimeIndex::LLMimeIndex() : mImpl(new LLMimeIndex::Impl)
{
}

LLMimeIndex::LLMimeIndex(LLSD headers, S32 content_offset) :
        mImpl(new LLMimeIndex::Impl(headers, content_offset))
{
}

LLMimeIndex::LLMimeIndex(const LLMimeIndex& mime) :
        mImpl(mime.mImpl)
{
        ++mImpl->mUseCount;
}

LLMimeIndex::~LLMimeIndex()
{
        if(0 == --mImpl->mUseCount)
        {
                delete mImpl;
        }
}

LLMimeIndex& LLMimeIndex::operator=(const LLMimeIndex& mime)
{
        // Increment use count first so that we handle self assignment
        // automatically.
        ++mime.mImpl->mUseCount;
        if(0 == --mImpl->mUseCount)
        {
                delete mImpl;
        }
        mImpl = mime.mImpl;
        return *this;
}

bool LLMimeIndex::attachSubPart(LLMimeIndex sub_part)
{
        // *FIX: Should we check for multi-part?
        if(mImpl->mAttachments.size() < S32_MAX)
        {
                mImpl->mAttachments.push_back(sub_part);
                return true;
        }
        return false;
}

class LLMimeParser::Impl
{
public:
        // @brief Constructor.
        Impl();

        // @brief Reset this for a new parse.
        void reset();

        bool parseIndex(
                std::istream& istr,
                S32 limit,
                const std::string& separator,
                bool is_subpart,
                LLMimeIndex& index);

protected:
        bool parseHeaders(std::istream& istr, S32 limit, LLSD& headers);

        std::string findSeparator(std::string multipart_content_type);

        void scanPastSeparator(
                std::istream& istr,
                S32 limit,
                const std::string& separator);

        void scanPastContent(
                std::istream& istr,
                S32 limit,
                LLSD headers,
                const std::string separator);

        bool eatCRLF(std::istream& istr);

        // @brief Returns true if parsing should continue.
        bool continueParse() const { return (!mError && mContinue); }

        // @brief anonymous enumeration for parse buffer size.
        enum
        {
                LINE_BUFFER_LENGTH = 1024
        };

protected:
        S32 mScanCount;
        bool mContinue;
        bool mError;
        char mBuffer[LINE_BUFFER_LENGTH];
};

LLMimeParser::Impl::Impl()
{
        reset();
}

void LLMimeParser::Impl::reset()
{
        mScanCount = 0;
        mContinue = true;
        mError = false;
        mBuffer[0] = '\0';
}

bool LLMimeParser::Impl::parseIndex(
        std::istream& istr,
        S32 limit,
        const std::string& separator,
        bool is_subpart,
        LLMimeIndex& index)
{
        LLSD headers;
        bool parsed_something = false;
        if(parseHeaders(istr, limit, headers))
        {
                parsed_something = true;
                LLMimeIndex mime(headers, mScanCount);
                index = mime;
                if(index.isMultipart())
                {
                        // Figure out the separator, scan past it, and recurse.
                        std::string ct = headers[CONTENT_TYPE].asString();
                        std::string sep = findSeparator(ct);
                        scanPastSeparator(istr, limit, sep);
                        while(continueParse() && parseIndex(istr, limit, sep, true, mime))
                        {
                                index.attachSubPart(mime);
                        }
                }
                else
                {
                        // Scan to the end of content.
                        scanPastContent(istr, limit, headers, separator);
                        if(is_subpart)
                        {
                                scanPastSeparator(istr, limit, separator);
                        }
                }
        }
        if(mError) return false;
        return parsed_something;
}

bool LLMimeParser::Impl::parseHeaders(
        std::istream& istr,
        S32 limit,
        LLSD& headers)
{
        while(continueParse())
        {
                // Get the next line.
                // We subtract 1 from the limit so that we make sure
                // not to read past limit when we get() the newline.
                S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
                istr.getline(mBuffer, max_get, '\r');
                mScanCount += istr.gcount();
                int c = istr.get();
                if(EOF == c)
                {
                        mContinue = false;
                        return false;
                }
                ++mScanCount;
                if(c != '\n')
                {
                        mError = true;
                        return false;
                }
                if(mScanCount >= limit)
                {
                        mContinue = false;
                }

                // Check if that's the end of headers.
                if('\0' == mBuffer[0])
                {
                        break;
                }

                // Split out the name and value.
                // *NOTE: The use of strchr() here is safe since mBuffer is
                // guaranteed to be NULL terminated from the call to getline()
                // above.
                char* colon = strchr(mBuffer, ':');
                if(!colon)
                {
                        mError = true;
                        return false;
                }

                // Cononicalize the name part, and store the name: value in
                // the headers structure. We do this by iterating through
                // 'known' headers and replacing the value found with the
                // correct one.
                // *NOTE: Not so efficient, but iterating through a small
                // subset should not be too much of an issue.
                std::string name(mBuffer, colon++ - mBuffer);
                while(isspace(*colon)) ++colon;
                std::string value(colon);
                for(S32 ii = 0; ii < KNOWN_HEADER_COUNT; ++ii)
                {
                        if(0 == LLString::compareInsensitive(
                                name.c_str(),
                                KNOWN_HEADER[ii].c_str()))
                        {
                                name = KNOWN_HEADER[ii];
                                break;
                        }
                }
                headers[name] = value;
        }
        if(headers.isUndefined()) return false;
        return true;
}

std::string LLMimeParser::Impl::findSeparator(std::string header)
{
        //                               01234567890
        //Content-Type: multipart/mixed; boundary="segment"
        std::string separator;
        std::string::size_type pos = header.find(BOUNDARY);
        if(std::string::npos == pos) return separator;
        pos += BOUNDARY.size() + 1;
        std::string::size_type end;
        if(header[pos] == '"')
        {
                // the boundary is quoted, find the end from pos, and take the
                // substring.
                end = header.find('"', ++pos);
                if(std::string::npos == end)
                {
                        // poorly formed boundary.
                        mError = true;
                }
        }
        else
        {
                // otherwise, it's every character until a whitespace, end of
                // line, or another parameter begins.
                end = header.find_first_of(END_OF_CONTENT_PARAMETER, pos);
                if(std::string::npos == end)
                {
                        // it goes to the end of the string.
                        end = header.size();
                }
        }
        if(!mError) separator = header.substr(pos, end - pos);
        return separator;
}

void LLMimeParser::Impl::scanPastSeparator(
        std::istream& istr,
        S32 limit,
        const std::string& sep)
{
        std::ostringstream ostr;
        ostr << SEPARATOR_PREFIX << sep;
        std::string separator = ostr.str();
        bool found_separator = false;
        while(!found_separator && continueParse())
        {
                // Subtract 1 from the limit so that we make sure not to read
                // past limit when we get() the newline.
                S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
                istr.getline(mBuffer, max_get, '\r');
                mScanCount += istr.gcount();
                if(istr.gcount() >= LINE_BUFFER_LENGTH - 1)
                {
                        // that's way too long to be a separator, so ignore it.
                        continue;
                }
                int c = istr.get();
                if(EOF == c)
                {
                        mContinue = false;
                        return;
                }
                ++mScanCount;
                if(c != '\n')
                {
                        mError = true;
                        return;
                }
                if(mScanCount >= limit)
                {
                        mContinue = false;
                }
                if(0 == LLString::compareStrings(mBuffer, separator.c_str()))
                {
                        found_separator = true;
                }
        }
}

void LLMimeParser::Impl::scanPastContent(
        std::istream& istr,
        S32 limit,
        LLSD headers,
        const std::string separator)
{
        if(headers.has(CONTENT_LENGTH))
        {
                S32 content_length = headers[CONTENT_LENGTH].asInteger();
                // Subtract 2 here for the \r\n after the content.
                S32 max_skip = llmin(content_length, limit - mScanCount - 2);
                istr.ignore(max_skip);
                mScanCount += max_skip;

                // *NOTE: Check for hitting the limit and eof here before
                // checking for the trailing EOF, because our mime parser has
                // to gracefully handle incomplete mime entites.
                if((mScanCount >= limit) || istr.eof())
                {
                        mContinue = false;
                }
                else if(!eatCRLF(istr))
                {
                        mError = true;
                        return;
                }
        }
}

bool LLMimeParser::Impl::eatCRLF(std::istream& istr)
{
        int c = istr.get();
        ++mScanCount;
        if(c != '\r')
        {
                return false;
        }
        c = istr.get();
        ++mScanCount;
        if(c != '\n')
        {
                return false;
        }
        return true;
}
        

LLMimeParser::LLMimeParser() : mImpl(* new LLMimeParser::Impl)
{
}

LLMimeParser::~LLMimeParser()
{
        delete & mImpl;
}

void LLMimeParser::reset()
{
        mImpl.reset();
}

bool LLMimeParser::parseIndex(std::istream& istr, LLMimeIndex& index)
{
        std::string separator;
        return mImpl.parseIndex(istr, S32_MAX, separator, false, index);
}

bool LLMimeParser::parseIndex(
        const std::vector<U8>& buffer,
        LLMimeIndex& index)
{
        LLMemoryStream mstr(&buffer[0], buffer.size());
        return parseIndex(mstr, buffer.size() + 1, index);
}

bool LLMimeParser::parseIndex(
        std::istream& istr,
        S32 limit,
        LLMimeIndex& index)
{
        std::string separator;
        return mImpl.parseIndex(istr, limit, separator, false, index);
}

bool LLMimeParser::parseIndex(const U8* buffer, S32 length, LLMimeIndex& index)
{
        LLMemoryStream mstr(buffer, length);
        return parseIndex(mstr, length + 1, index);
}

/*
bool LLMimeParser::verify(std::istream& isr, LLMimeIndex& index) const
{
        return false;
}

bool LLMimeParser::verify(U8* buffer, S32 length, LLMimeIndex& index) const
{
        LLMemoryStream mstr(buffer, length);
        return verify(mstr, index);
}
*/

---