HttpFormDataDecoder Class Reference

#include <HttpCollection.h>

Inheritance diagram for HttpFormDataDecoder:

Public Member Functions
	HttpFormDataDecoder (size_t _bufferSize=4096)
virtual	~HttpFormDataDecoder ()
void	decode (InputStream &_input, const char *_contentType, size_t _contentLength, ListedStringToStringArrayMap &_mapForm, HttpFormData &_mapFormFile) __DCL_THROWS1(HttpFormDataDecoderException *)
const String	warnings () const
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Additional Inherited Members
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Detailed Description

Definition at line 147 of file HttpCollection.h.

Constructor & Destructor Documentation

HttpFormDataDecoder()

HttpFormDataDecoder::HttpFormDataDecoder

(

size_t

_bufferSize = 4096

)

~HttpFormDataDecoder()

HttpFormDataDecoder::~HttpFormDataDecoder ( )

virtual

Definition at line 304 of file HttpCollection.cpp.

{
    if (__buffer) {
        free(__buffer);
    }
}

Member Function Documentation

decode()

void HttpFormDataDecoder::decode	(	InputStream &	_input,
		const char *	_contentType,
		size_t	_contentLength,
		ListedStringToStringArrayMap &	_mapForm,
		HttpFormData &	_mapFormFile )

Definition at line 311 of file HttpCollection.cpp.

{
    __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[%hs]\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"%ls\n", strMsg.data());
 
                if (!_mapFormFile.onFileEnd(
                    header,
                    pCallbackData,
                    false,
                    strCallbackError
                )) {
                    __DCL_TRACE1(L"HttpFormData::onFileEnd: %ls\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;
            }
        }       
    }
}

warnings()

const String HttpFormDataDecoder::warnings ( ) const

inline

Definition at line 170 of file HttpCollection.h.

{ return __warnings; }

---

The documentation for this class was generated from the following files:

• HttpCollection.h
• HttpCollection.cpp