HttpCollection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
#endif
 
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Numeric.h>
 
#include <dcl/URI.h>
#include <dcl/HttpServlet.h>
#include <dcl/HttpCollection.h>
#include <dcl/Array.h>
#include <dcl/Charset.h>
#include <dcl/BytesOutputStream.h>
#include <dcl/FileOutputStream.h>
#include <dcl/Files.h>
 
#define __DEBUG_THIS    0
#if __DEBUG_THIS
#define __DCL_TRACE1_N  __DCL_TRACE1
#define __DCL_TRACE2_N  __DCL_TRACE2
#define __DCL_TRACE3_N  __DCL_TRACE3
#else
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#endif
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t* __THIS_FILE__ = __T("dcl/HttpCollection.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
void HttpCookieDecoder::decode(
        const ByteString& _contents,
        ListedStringToStringMap& _results
        )
{
    ByteStringArray elements;
    _contents.split(';', elements);
 
    for(ByteStringArray::Iterator it = elements.begin();
        it != elements.end(); it++) {
        ByteStringArray pair;
        ByteString name;
        ByteString value;
 
        (*it).split('=', pair);
        ByteStringArray::Iterator itPair = pair.begin();
 
        if (itPair != pair.end()) {
            name = (*itPair);   // .trim();
 
            itPair++;
            if (itPair != pair.end()) {
                value = (*itPair);  // .trim();
            }
 
            _results[UTF8Decoder::decode(name)] =
                UTF8Decoder::decode(value);
        }
    }
}
 
void HttpQueryStringDecoder::decode(
        const ByteString& _queryString,
        ListedStringToStringArrayMap& _results
)
{
    return HttpQueryStringDecoder::decode(
        _queryString,
        _queryString.data() + _queryString.length(),
        _results
        );
}
 
void HttpQueryStringDecoder::decode(
        const char* _begin,
        const char* _end,
        ListedStringToStringArrayMap& _results
    )
{
    ByteStringArray elements;
    ByteString::split(_begin, _end, '&', elements);
 
    for(ByteStringArray::Iterator it = elements.begin();
        it != elements.end(); it++) 
    {
        ByteStringArray pair;
        ByteString name;
        ByteString value;
 
        (*it).split(L'=', pair);
        ByteStringArray::Iterator itPair = pair.begin();
 
        if (itPair != pair.end()) {
            //name = URLDecoder::decode(*itPair); // .trim();
            name = *itPair;
            if (!name.isEmpty()) {
                itPair++;
                value = itPair != pair.end() ? 
                    URLDecoder::decode(*itPair) : "";
 
                (_results[UTF8Decoder::decode(name)])
                    .add(UTF8Decoder::decode(value));
            }
        }
    }
}
 
bool HttpQueryStringDecoder::isValidType(
                const char* _contentType
                )
{
    __DCL_ASSERT(_contentType != NULL 
            && *_contentType != '\0');
 
    while(isspace((wint_t)*_contentType))
        _contentType++;
 
    return ByteString::compareNoCase(
                _contentType,
                "application/x-www-form-urlencoded",
                33
                ) == 0;
}
 
String HttpQueryStringEncoder::encode(
        const ListedStringToStringArrayMap& _map
        )
{
    ByteStringBuilder sb;
    
    for(ListedStringToStringArrayMap::ConstIterator it = _map.begin();
            _map.end() != it; it++) 
    {
        if (!sb.isEmpty())
            sb += "&";
 
        const ByteString name = UTF8Encoder::encode((*it).key);
        const StringArray& values = (*it).value;
        for(size_t i = 0; i < values.size(); i++) {
            sb += name;
            sb += '=';
            sb += UTF8Encoder::encode(values[i]);
        }
    }
 
    return AsciiDecoder::decode(URLEncoder::encode(sb));
}
 
IMPLEMENT_CLASSINFO(HttpFormData, Object)
 
String HttpFormData::PartHeader::toString() const
{
    StringBuilder sb;
    sb.append(L"type[").append(type)
        .append(L"], name[").append(name)
        .append(L"], filename[").append(filename)
        .append(L"], contentType[").append(contentType)
        .append(L"]");
    return sb;
}
 
// default file handler
// data ignored
 
bool HttpFormData::onFileStart(
        const PartHeader& header,
        void** ppCallbackData,
        String& strCallbackError    // return false 이면
        )
{
#ifdef __DCL_DEBUG
    size_t* pTotalSize = new size_t;
    __DCL_ASSERT(pTotalSize != NULL);
 
    *pTotalSize = 0;
 
    *ppCallbackData = pTotalSize;
#endif
    return true;
}
 
bool HttpFormData::onFileData(
        const void* pData,
        size_t      nSize,
        void*       pCallbackData,
        String&     strCallbackError    // return false 이면
        )
{
#ifdef __DCL_DEBUG
    size_t* pTotalSize = (size_t*)pCallbackData;
    *pTotalSize += nSize;
#endif
    return true;
}
 
bool HttpFormData::onFileEnd(
        const PartHeader& header,
        void*       pCallbackData,
        bool        bDataSuccess,
        String&     strCallbackError    // return false 이면
        )
{
#ifdef __DCL_DEBUG
    size_t* pTotalSize = (size_t*)pCallbackData;
    
    StringBuilder sb = L"Warning! name=\"";
    sb += header.name + L"\" filename=\"";
    sb += header.filename + L"\" ";
    sb += String::valueOf(*pTotalSize) + L" bytes";
    if (!bDataSuccess)
        sb += L", in data error";
    sb += L", discarded\n";
    __DCL_TRACE0(sb.data());
    delete pTotalSize;
#endif
    return true;
}
 
IMPLEMENT_CLASSINFO(HttpFormDataDecoderException, Exception)
 
HttpFormDataDecoderException::HttpFormDataDecoderException(
        ErrorCode errorCode,
        IOException* pDetailEx
        )
    : Exception(pDetailEx)
{
    m_errorCode = errorCode;
}
 
HttpFormDataDecoderException::HttpFormDataDecoderException(
        ErrorCode errorCode,
        const String& strMsg
        )
    : Exception(NULL)
{
    m_errorCode = errorCode;
    m_strMsg = strMsg;
}
 
String HttpFormDataDecoderException::toString() const
{
    StringBuilder str;
    switch(m_errorCode) {
    case ePostReadError :
        str = L"HTTP POST read error - See Detail Exception";
        break;
    case eFormDataCallbackError :
        str = L"HttpFormData Object callback error";
        break;
    default :
        __DCL_ASSERT(false);
    }
 
    if (!m_strMsg.isEmpty()) {
        str += L": " + m_strMsg;
    }
    return str;
}
 
IMPLEMENT_CLASSINFO(HttpFormDataDecoder, Object)
 
HttpFormDataDecoder::HttpFormDataDecoder(
            size_t  _bufferSize     // = 4096
            )
{
    __input = NULL;
    __contentLength = 0;
    __remainder = 0;
 
    __buffer = NULL;
    __bufferSize = _bufferSize;
    __begin = NULL;
    __end = NULL;
 
    __contentDisposition = "Content-Disposition";
    __contentType  = "Content-Type";
    __name = "name";
    __filename = "filename";
 
}
 
HttpFormDataDecoder::~HttpFormDataDecoder()
{
    if (__buffer) {
        free(__buffer);
    }
}
 
void HttpFormDataDecoder::decode(
        InputStream& _input,
        const char*     _contentType,
        size_t          _contentLength,
        ListedStringToStringArrayMap& _mapForm,
        HttpFormData&   _mapFormFile
        ) __DCL_THROWS1(HttpFormDataDecoderException*)
{
    __DCL_ASSERT(_contentType != NULL && *_contentType != '\0');
    __DCL_ASSERT(_contentLength > 0);
 
    __input = &_input;
    __contentLength = _contentLength;
    __remainder = _contentLength;
 
    ByteString boundary = "--";
    {
        ByteString strOrgBoundary = getBoundary(_contentType);
        if (strOrgBoundary.isEmpty()) {
            appendWarning(L"Error! invalid boundary");
            return;
        }
        boundary = boundary + strOrgBoundary;
    }
 
    __DCL_ASSERT(__bufferSize > (size_t)(boundary.length() + 2));
 
    __DCL_TRACE1_N(L"boundary[%s]\n", boundary.data());
 
    if(!readInput()) {
        appendWarning(L"Warning! Input data empty");
        return;
    }
 
    bool bNextPart = getFirstBoundary(boundary);
 
    while(bNextPart) {
        HttpFormData::PartHeader header;
        if (!getPartHeader(header)) {
            appendWarning(L"Warning! not found boundary delimiter");
            break;
        }
 
        __DCL_TRACE1_N(L"partHeader %ls\n", header.toString().data());
 
        // Content-Type: multipart/mixed 이면 위치에서 
        // HttpFormDataDecoder::decode를 재귀적으로 호출한다.
        // RFC1867에는 2개이상의 파일을 포함할 경우 multipart/mixed
        // 를 사용한다고 되어 있으나 Microsoft-IE, Netscape Navigator
        // 모두 그렇게 하고 있지 않고 있다.
 
        if (header.filename.isEmpty()) {
            // normal data
            ByteStringBuilder value;
 
            char* _begin = NULL;
            char* _end = NULL;
            DataState ds = dsNeedMoreData;
            while((ds = getDataBlock(boundary, _begin, _end)) == dsNeedMoreData) {
                if (_begin < _end) {
                    value.append(_begin, _end);
                }
 
                if (!readInput()) {
                    // EOF : data error
                    break;
                }
            }
 
            if (ds == dsNeedMoreData) {
                // 데이터 에러: EOF or too small data
                // 더이상 데이터가 없다. 데이터 에러이다.
                // 데이터는 무시한다.
                String strMsg = header.name 
                            + L": invalid data, discarded";
                appendWarning(strMsg);
                __DCL_TRACE1_N(L"%ls\n", strMsg.data());
 
                bNextPart = false;
            }
            else {
                // 정상 데이터
                // 마지막 데이터 추가
                if (_begin < _end) {
                    value.append(_begin, _end);
                }
 
                (_mapForm[header.name]).add(UTF8Decoder::decode(value));
 
                if (ds == dsBeforeCloseBoundary)
                    bNextPart = false;
            }
        }
        else {
            // input type=file
            void* pCallbackData = NULL;
            String strCallbackError;
            if (!_mapFormFile.onFileStart(
                                        header,
                                        &pCallbackData,
                                        strCallbackError
                                        )
                                    ) {
                // callback 시작에서 에러가 발생하면 decoding을 중단한다.
                throw new HttpFormDataDecoderException(
                        HttpFormDataDecoderException::eFormDataCallbackError,
                        strCallbackError
                        );
            }
 
            char* _begin = NULL;
            char* _end = NULL;
            DataState ds = dsNeedMoreData;
            while((ds = getDataBlock(boundary, _begin, _end)) == dsNeedMoreData) {
                if (_begin < _end) {
                    // 데이터가 있으면
                    if (!_mapFormFile.onFileData(
                                        _begin,
                                        _end - _begin,
                                        pCallbackData,
                                        strCallbackError
                                        )) {
                        throw new HttpFormDataDecoderException(
                                HttpFormDataDecoderException::eFormDataCallbackError,
                                strCallbackError
                                );
                    }
                }
 
                try {
                    if (!readInput()) {
                        // EOF : data error
                        break;
                    }
                }
                catch (HttpFormDataDecoderException* e) {
                    if (!_mapFormFile.onFileEnd(
                                    header,
                                    pCallbackData,
                                    false,
                                    strCallbackError
                                    )) {
                        __DCL_TRACE1(L"HttpFormData::onFileEnd: %ls\n", strCallbackError.data());
                    }
 
                    throw e;
                }
            }   // end of while
 
            if (ds == dsNeedMoreData) {
                // 데이터 에러: EOF or too small data
                // 더이상 데이터가 없다. 데이터 에러이다.
                // 읽혀진 데이터는 버린다.
                String strMsg = header.name
                            + L":\""    + header.filename 
                            + L"\": invalid data, discarded";
 
                appendWarning(strMsg);
                __DCL_TRACE1_N(L"%s\n", strMsg.data());
 
                if (!_mapFormFile.onFileEnd(
                                header,
                                pCallbackData,
                                false,
                                strCallbackError
                                )) {
                    __DCL_TRACE1(L"HttpFormData::onFileEnd: %s\n", strCallbackError.data());
                }
 
                bNextPart = false;
            }
            else {
                // 정상 데이터
                if (_begin < _end) {
                    if (!_mapFormFile.onFileData(
                                        _begin,
                                        _end - _begin,
                                        pCallbackData,
                                        strCallbackError
                                        )
                                    ) {
                        throw new HttpFormDataDecoderException(
                                HttpFormDataDecoderException::eFormDataCallbackError,
                                strCallbackError
                                );
                    }
                }
 
                if (!_mapFormFile.onFileEnd(
                        header,
                        pCallbackData,
                        true,
                        strCallbackError
                        )
                    ) {
                    throw new HttpFormDataDecoderException(
                            HttpFormDataDecoderException::eFormDataCallbackError,
                            strCallbackError
                            );
                }
 
                if (ds == dsBeforeCloseBoundary)
                    bNextPart = false;
            }
        }       
    }
}
 
#undef CR
#undef LF
#define CR '\r'
#define LF '\n'
 
// CRLF을 찾으면 CR의 포인터를, 없으면 NULL을 반환한다.
inline char* __find_CRLF(
        char* _begin, char* _end
        )
{
    _end--;
    while (_begin < _end) {
        if (*_begin == CR && *(_begin + 1) == LF) {
            return _begin;
        }
        _begin++;
    }
    return NULL;
}
 
inline char* __find_CHAR(
        char* _begin, char* _end, char _ch
        )
{
    while (_begin < _end) {
        if (*_begin == _ch) {
            return _begin;
        }
        _begin++;
    }
    return NULL;
}
 
HttpFormDataDecoder::DataState
HttpFormDataDecoder::getDataBlock(
        const ByteString& _boundary,
        char*& _begin,
        char*& _end
        )
{
    __DCL_ASSERT(__buffer != NULL);
    __DCL_ASSERT(__begin <= __end);
 
    // 시작 시점에서 버퍼는 적어도 
    // boundary.length() + 2 (close boundary size) 보다 작으면
    // 데이터가 유효하지 않다.
    if (!((__begin + _boundary.length() + 2) <= __end)) {
        return dsNeedMoreData;
    }
 
    // CRLF를 확인한 후 CRLF의 이후가 boundary이면
    // CRLF까지를 _end로
    _end = _begin = __begin;
    char* atCR = NULL;
    while((atCR = __find_CRLF(_end, __end)) != NULL) {
        // CRLF를 찾았다.
        // CRLF 다음이 boundary이면 atCR까지이고,
        // 그렇지 않으면 다음 CRLF를 찾는다.
        _end = atCR;
        char* afterCRLF = atCR + 2;
        __DCL_ASSERT(afterCRLF <= __end);
        if ((afterCRLF + _boundary.length()) <= __end) {
            if (!memcmp(_boundary.data(), afterCRLF, _boundary.length())) {
                DataState dsReturn = dsBeforeNextBoundary;
                afterCRLF += _boundary.length();
                if (afterCRLF + 2 <= __end
                    && !memcmp(afterCRLF, "--", 2)) {
                    // close boundary
                    dsReturn = dsBeforeCloseBoundary;
                }
                
                // boundary 이후에 CRLF가 있다. skip한다.
                char* p = __find_CRLF(afterCRLF, __end);
                if (p) {
                    afterCRLF = p + 2;
                }
 
                __DCL_ASSERT(afterCRLF <= __end);
                __begin = afterCRLF;
                return dsReturn;
            }
            _end = afterCRLF;
            // 다음 CRLF를 찾는다.
        }
        else {
            // 버퍼의 데이터가 작다. CRLF 찾는것을 종료한다.
            break;
        }
    }
 
    __DCL_ASSERT(__begin <= _end);
    if (__begin == _end) {
        // 한번도 CRLF를 못 찾았다.
        _end = __end - 1;
        if (*_end != CR)
            _end++;
    }
 
    __begin = _end;
    return dsNeedMoreData;
}   
 
bool HttpFormDataDecoder::getLine(
        char*& _begin, char*& _end
        )
{
    __DCL_ASSERT(__buffer != NULL);
    char* atCR = __find_CRLF(__begin, __end);
    if (!atCR) {
        return false;
    }
 
    _begin = __begin;
    _end = __begin = atCR;
 
    // __begin은 CRLF의 다음으로
    __begin += 2;
 
    while (_begin < _end) {
        if (!isspace(*_begin)) {
            break;
        }
        _begin++;
    }
 
    return true;
}
 
bool HttpFormDataDecoder::getFirstBoundary(
        const ByteString& _boundary
        )
{
    char* _begin;
    char* _end;
    while(getLine(_begin, _end)) {
        if (((_begin + _boundary.length()) <= _end)
            && (!memcmp(_boundary.data(), _begin, _boundary.length()))) {
            // check end boundary
            _begin += _boundary.length();
            if (!ByteString::compare(_begin, "--", 2)) {
                // data error
                return false;
            }
            return true;
        }
    }
    // data error 
    return false;
}
 
#define EQUAL_STR(str, p) (!(str).compareNoCase((p), str.length()))
bool HttpFormDataDecoder::getPartHeader(
        HttpFormData::PartHeader& header
        ) __DCL_THROWS1(HttpFormDataDecoderException*)
{
    for( ; ; ) {
        char* _begin;
        char* _end;
        if (!getLine(_begin, _end)) {
            if (!readInput())
                return false;
            if (!getLine(_begin, _end))
                return false;
        }
 
        if (!(_begin < _end)) {
            // 헤더를 모두 읽었다 
            break;
        }
    
        char* _value = __find_CHAR(_begin, _end, ':');
        if (!_value) {
            // invalid line
            continue;
        }
        while(isspace((byte_t)*(++_value)));
 
        if (EQUAL_STR(__contentDisposition, _begin)) {
            _begin = _value;
            while(_begin < _end) {
                char* _next = __find_CHAR(_begin, _end, ';');
                if (!_next) {
                    _next = _end;
                }
 
                _value = __find_CHAR(_begin, _next, '=');
                if (_value) {
                    while(isspace((byte_t)*(++_value)));
 
                    if (EQUAL_STR(__name, _begin)) {
                        header.name = UTF8Decoder::decode(_value, _next - _value).trim(L"\"");
                    }
                    else if (EQUAL_STR(__filename, _begin)) {
                        header.filename = UTF8Decoder::decode(_value, _next - _value).trim(L"\"");
                        // IE는 절대경로를 포함하고 netscape는 basename이다.
                        size_t index = header.filename.lastIndexOf(L'\\');
                        if (index != (size_t)-1) {
                            header.filename = header.filename.mid(index + 1);
                        }
                    }
                    else {
                        String s = String::format(L"unknown property [%ls]", 
                            UTF8Decoder::decode(_begin, _end - _begin).data());
                        appendWarning(s);
                        __DCL_TRACE1_N(L"%ls\n", s.data());
                    }
                }
                else {
                    header.type = UTF8Decoder::decode(_begin, _next - _begin);
                }
 
                if (_next < _end) {
                    while (isspace((byte_t) * (++_next)));
                }
                _begin = _next;
            }
        }
        else if (EQUAL_STR(__contentType, _begin)) {
            header.contentType = UTF8Decoder::decode(_value, _end - _value);
        }
        else {
            String s = String::format(L"Invalid header [%ls]",
                UTF8Decoder::decode(_begin, _end - _begin).data());
            appendWarning(s);
            __DCL_TRACE1_N(L"%ls\n", s.data());
        }
    }
 
    return true;
}
 
bool HttpFormDataDecoder::readInput()
         __DCL_THROWS1(HttpFormDataDecoderException*)
{
    if (__remainder) {
        try {
            if (!__buffer) {
                __buffer = (char*)malloc(__bufferSize + 1);
                __DCL_ASSERT(__buffer != NULL);
                *(__buffer + __bufferSize) = '\0';
 
                __begin = __buffer;
                __end = __buffer;
            }
 
            size_t n = __end - __begin;
            if (n) {
                memmove(__buffer, __begin, n);
                __begin = __buffer;
                __end = __buffer + n;
            }
            else {
                // 캐시된 데이터가 없다. 전체를 다시 읽어야 한다.
                __begin = __buffer;
                __end = __buffer;
            }
 
            size_t nCanRead = __bufferSize - n;
            if (__remainder < nCanRead)
                nCanRead = __remainder;
 
            size_t nRead = __input->read(__end, nCanRead);
            __end += nRead;
            __DCL_TRACE2_N(L"CanRead: %d, Read: %d\n", nCanRead, nRead);
            __remainder -= nRead;
 
            return true;
        }
        catch(IOException* eCause) {
            throw new HttpFormDataDecoderException(
                    HttpFormDataDecoderException::ePostReadError,
                    eCause
                    );
        }
    }
    return false;
}
 
void HttpFormDataDecoder::appendWarning(const String& _warning)
{
 
    if (!__warnings.isEmpty())
        __warnings += L'\n';
 
    __warnings += _warning;
}
 
// static members
ByteString HttpFormDataDecoder::getBoundary(
            const char* _contentType
            )
{
    __DCL_ASSERT(_contentType != NULL && *_contentType != '\0');
    
    ByteStringBuilder sb;
 
    const char* p = strstr(_contentType, "boundary");
    if (p) {
        p += 8; // strlen("boundary");
        p = strchr(p, '=');
        if (p) {
            while(isspace((byte_t)*(++p)))
                ;
            sb = p;
            sb.trim();
        }
    }
 
    return sb;
}
 
bool HttpFormDataDecoder::isValidType(const char* _contentType)
{
    __DCL_ASSERT(_contentType != NULL 
            && *_contentType != '\0');
 
    while(isspace((byte_t)*_contentType))
        _contentType++;
 
    return ByteString::compareNoCase(
                _contentType,
                "multipart/form-data",
                19
                ) == 0;
}
 
IMPLEMENT_CLASSINFO(BufferedHttpFormData, HttpFormData)
 
BufferedHttpFormData::FileInfo::FileInfo()
{
}
 
#undef __V
#define __V()   ((PointerArray*)__handle)
BufferedHttpFormData::FileInfo&
BufferedHttpFormData::FileInfoArray::operator[] (size_t _index)
{
    __DCL_ASSERT(_index < __V()->size());
 
    return *((FileInfo*)((*__V())[_index]));
}
        
size_t BufferedHttpFormData::FileInfoArray::size() const
{
    __DCL_ASSERT(__handle != NULL);
 
    return __V()->size();
}
 
bool BufferedHttpFormData::FileInfoArray::isEmpty() const
{
    __DCL_ASSERT(__handle != NULL);
 
    return __V()->isEmpty();
}
 
BufferedHttpFormData::FileInfoArray::FileInfoArray(const String& _name)
{
    __handle = new PointerArray();
    __name = _name;
 
    __DCL_ASSERT(__handle != NULL);
}
 
BufferedHttpFormData::FileInfoArray::FileInfoArray(const FileInfo& src)
{
    // 결코 불려져서는 안됨
    __DCL_ASSERT(false);
}
 
BufferedHttpFormData::FileInfoArray::~FileInfoArray()
{
    __DCL_ASSERT(__handle != NULL);
    PointerArray* p = __V();
    PointerArray& v = *p;
    for(size_t i = 0; i < v.size(); i++)
        delete (FileInfo*)v[i];
    v.clear();
    delete p;
}
 
void BufferedHttpFormData::FileInfoArray::add(FileInfo* pNewItem)
{
    __DCL_ASSERT(pNewItem != NULL);
    __V()->add(pNewItem);
}
 
BufferedHttpFormData::BufferedHttpFormData()
{
    __handle = new PointerArray();
    __DCL_ASSERT(__handle != NULL);
}
 
BufferedHttpFormData::~BufferedHttpFormData()
{
    __DCL_ASSERT(__handle != NULL);
    PointerArray* p = __V();
    PointerArray& v = *p;
    for(size_t i = 0; i < v.size(); i++)
        delete (FileInfoArray*)v[i];
    v.clear();
    delete p;
}
 
size_t BufferedHttpFormData::size() const
{
    __DCL_ASSERT(__handle != NULL);
    return __V()->size();
}
 
bool BufferedHttpFormData::isEmpty() const
{
    __DCL_ASSERT(__handle != NULL);
 
    return __V()->isEmpty();
}
 
BufferedHttpFormData::FileInfoArray&
BufferedHttpFormData::operator[] (size_t _index)
{
    __DCL_ASSERT(_index < __V()->size());
    return *((FileInfoArray*)((*__V())[_index]));
}
 
BufferedHttpFormData::FileInfoArray&
BufferedHttpFormData::byName(const wchar_t* _name)
                __DCL_THROWS1(InvalidIndexException*)
{
    __DCL_ASSERT(_name != NULL && *_name != '\0');
 
    FileInfoArray* pV = NULL;
    PointerArray& v = *(PointerArray*)__handle;
    for(size_t i = 0; i < v.size(); i++)
    {
        pV = (FileInfoArray*)(v[i]);
        if (pV->__name == _name)
            return *pV;
    }
 
    pV = new FileInfoArray(_name);
    v.add(pV);
    return *pV;
}
 
void BufferedHttpFormData::insert(
                const String& _name,
                FileInfo* pNewItem
                )
{
    __DCL_ASSERT(!_name.isEmpty());
 
    FileInfoArray& v = byName(_name);
    v.add(pNewItem);
}

bool BufferedHttpFormData::onFileStart(
        const PartHeader& header,
        void**      ppCallbackData,
        String&     strCallbackError    // return false 이면
        )
{
    BytesOutputStream* pOut = new BytesOutputStream;
    __DCL_ASSERT(pOut != NULL);
 
    *ppCallbackData = pOut;
 
    return true;
}
 
bool BufferedHttpFormData::onFileData(
                const void* pData,
                size_t      nSize,
                void*       pCallbackData,
                String&     strCallbackError    // return false 이면
                )
{
    BytesOutputStream* pOut = (BytesOutputStream*)pCallbackData;
    __DCL_ASSERT(pOut != NULL);
 
    try {
        pOut->write(pData, nSize);
    }
    catch(IOException* e) {
        delete pOut;
 
        strCallbackError = e->toString();
        e->destroy();
        return false;
    }
 
    return true;
}
 
bool BufferedHttpFormData::onFileEnd(
        const PartHeader& header,
        void*       pCallbackData,
        bool        bDataSuccess,
        String&     strCallbackError    // return false 이면
        )
{
    BytesOutputStream* pOut = (BytesOutputStream*)pCallbackData;
    __DCL_ASSERT(pOut != NULL);
 
    if (bDataSuccess) {
        FileInfo* pInfo = new FileInfo;
 
        pInfo->filename = header.filename;
        pInfo->contentType = header.contentType;
        pInfo->fileData = pOut->toByteString();
 
        delete pOut;
 
        insert(header.name, pInfo);
    }
 
    return true;
}
 
IMPLEMENT_CLASSINFO(StoredHttpFormData, HttpFormData)
 
#undef __V
#define __V()   ((PointerArray*)__handle)
 
StoredHttpFormData::FileInfo::FileInfo()
{
    fileSize = 0;
}
 
StoredHttpFormData::FileInfo::FileInfo(const FileInfo& str)
{
    __DCL_ASSERT(false);
}
 
StoredHttpFormData::FileInfo::~FileInfo()
{
    try {
        if (Files::exists(tempFilename))
            Files::unlink(tempFilename);
    }
    catch(IOException* e) {
        __DCL_TRACE1(L"%ls\n", e->toString().data());
        e->destroy();
    }
}
 
StoredHttpFormData::FileInfo&
StoredHttpFormData::FileInfoArray::operator[] (size_t _index)
{
    __DCL_ASSERT( _index < __V()->size());
 
    return *((FileInfo*)((*__V())[_index]));
}
        
size_t StoredHttpFormData::FileInfoArray::size() const
{
    __DCL_ASSERT(__handle != NULL);
    return __V()->size();
}
 
bool StoredHttpFormData::FileInfoArray::isEmpty() const
{
    __DCL_ASSERT(__handle != NULL);
    return __V()->isEmpty();
}
 
StoredHttpFormData::FileInfoArray::FileInfoArray(const String& _name)
{
    __handle = new PointerArray;
    __name = _name;
 
    __DCL_ASSERT(__handle != NULL);
}
 
StoredHttpFormData::FileInfoArray::FileInfoArray(const FileInfo& src)
{
    // 결코 불려져서는 안됨
    __DCL_ASSERT(false);
}
 
StoredHttpFormData::FileInfoArray::~FileInfoArray()
{
    __DCL_ASSERT(__handle != NULL);
    PointerArray* p = __V();
    PointerArray& v = *p;
    for(size_t i = 0; i < v.size(); i++)
        delete (FileInfo*)v[i];
    v.clear();
    delete p;
}
 
void StoredHttpFormData::FileInfoArray::add(FileInfo* pNewItem)
{
    __DCL_ASSERT(pNewItem != NULL);
    __V()->add(pNewItem);
}
 
StoredHttpFormData::StoredHttpFormData(const String& strTempDir)
{
    __DCL_ASSERT(!strTempDir.isEmpty());
 
    __tempDir = strTempDir;
 
    __handle = new PointerArray;
    __DCL_ASSERT(__handle != NULL);
}
 
StoredHttpFormData::~StoredHttpFormData()
{
    __DCL_ASSERT(__handle != NULL);
    PointerArray* p = __V();
    PointerArray& v = *p;
    for(size_t i = 0; i < v.size(); i++)
        delete (FileInfoArray*)v[i];
    v.clear();
    delete p;
}
 
size_t StoredHttpFormData::size() const
{
    __DCL_ASSERT(__handle != NULL);
    return __V()->size();
}
 
bool StoredHttpFormData::isEmpty() const
{
    __DCL_ASSERT(__handle != NULL);
    return __V()->isEmpty();
}
 
StoredHttpFormData::FileInfoArray&
StoredHttpFormData::operator[] (size_t _index)
{
    __DCL_ASSERT(_index < __V()->size());
    return *((FileInfoArray*)((*__V())[_index]));
}
 
StoredHttpFormData::FileInfoArray&
StoredHttpFormData::byName(const wchar_t* _name)
                __DCL_THROWS1(InvalidIndexException*)
{
    __DCL_ASSERT(_name != NULL && *_name != '\0');
 
    FileInfoArray* pV = NULL;
    PointerArray& v = *(PointerArray*)__handle;
    for(size_t i = 0; i < v.size(); i++) {
        pV = (FileInfoArray*)(v[i]);
        if (pV->__name == _name)
            return *pV;
    }
 
    pV = new FileInfoArray(_name);
    v.add(pV);
    return *pV;
}
 
void StoredHttpFormData::insert(
                const String& _name,
                FileInfo* pNewItem
                )
{
    __DCL_ASSERT(!_name.isEmpty());
 
    FileInfoArray& v = byName(_name);
    v.add(pNewItem);
}

typedef struct _STORED_CALLBACK_DATA {
    String              tempFilename;
    size_t              dataSize;
    FileOutputStream*   output;
} STORED_CALLBACK_DATA;
 
bool StoredHttpFormData::onFileStart(
        const PartHeader& header,
        void**      ppCallbackData,
        String&     strCallbackError    // return false 이면
        )
{
    String filename;
    FileOutputStream* pOut = NULL;
    try {
        File* pFile = File::openTempFile(
                            __tempDir,
                            L"dclformdata"
                            );
        pOut = new FileOutputStream(pFile);
        filename = pFile->path();
    }
    catch(IOException* e) {
        if (!filename.isEmpty()) {
            try {
                Files::unlink(filename);
            }
            catch (IOException* e) {
                __DCL_TRACE1(L"%ls\n", e->toString().data());
                e->destroy();
            }
        }
        strCallbackError = e->toString();
        e->destroy();
        return false;
    }
 
    STORED_CALLBACK_DATA* pCB = new STORED_CALLBACK_DATA;
    __DCL_ASSERT(pCB != NULL);
    pCB->tempFilename = filename;
    pCB->output = pOut;
    pCB->dataSize = 0;
 
    *ppCallbackData = pCB;
 
    return true;
}
 
bool StoredHttpFormData::onFileData(
        const void* pData,
        size_t      nSize,
        void*       pCallbackData,
        String&     strCallbackError    // return false 이면
        )
{
    STORED_CALLBACK_DATA* pCB = (STORED_CALLBACK_DATA*)pCallbackData;
    __DCL_ASSERT(pCB != NULL);
 
    try {
        pCB->output->write(pData, nSize);
        pCB->dataSize += nSize;
    }
    catch(IOException* e) {
        try {
            delete pCB->output;
            Files::unlink(pCB->tempFilename);
        }
        catch(IOException* e) {
            __DCL_TRACE1(L"%ls\n", e->toString().data());
            e->destroy();
        }
 
        delete pCB;
 
        strCallbackError = e->toString();
        e->destroy();
        return false;
    }
    return true;
}
 
bool StoredHttpFormData::onFileEnd(
        const PartHeader& header,
        void*       pCallbackData,
        bool        bDataSuccess,
        String&     strCallbackError    // return false 이면
        )
{
    STORED_CALLBACK_DATA* pCB = (STORED_CALLBACK_DATA*)pCallbackData;
    __DCL_ASSERT(pCB != NULL);
    try {
        delete pCB->output;
 
        __DCL_TRACE2_N(
            L"fileSize: %zd, dataSize: %zd\n",
            Files::size(pCB->tempFilename),
            pCB->dataSize
            );
    }
    catch(IOException* e) {
        try {
            Files::unlink(pCB->tempFilename);
        }
        catch(IOException* e) {
            __DCL_TRACE1(L"%ls\n", e->toString().data());
            e->destroy();
        }
 
        strCallbackError = e->toString();
        e->destroy();
        delete pCB;
 
        return false;
    }
        
 
    if (bDataSuccess) {
        FileInfo* pInfo = new FileInfo;
 
        __DCL_ASSERT(pInfo != NULL);
 
        pInfo->filename = header.filename;
        pInfo->contentType = header.contentType;
        pInfo->fileSize = pCB->dataSize;
        pInfo->tempFilename = pCB->tempFilename;
 
        insert(header.name, pInfo);
    }
 
    delete pCB;
 
    return true;
}
 
__DCL_END_NAMESPACE