HttpServletEx.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
#else
    #include <pthread.h>
#endif
 
#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>
#ifdef __DCL_DEBUG
#include <dcl/Thread.h>
#endif
#include <dcl/Files.h>
#if 0
#include <dcl/FileOutputStream.h>
#endif
#include <dcl/HttpStream.h>
#include <dcl/HttpServletEx.h>
#include <dcl/StringWriter.h>
#include <dcl/Charset.h>
#include <dcl/OutputStreamWriter.h>
#include <dcl/BytesOutputStream.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t* __THIS_FILE__ = __T("dcl/HttpServletEx.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(HttpServletContextEx, HttpServletContext)
 
HttpServletContextEx::HttpServletContextEx(
        const DCL_HTTP_SERVER_API* _SAPI,
        const DCL_HTTP_SERVLET_CONTEXT* _context,
        const String& _tempPath
        )
    : HttpServletContext(_SAPI, _context), __formFileMap(_tempPath)
{
}
 
HttpServletContextEx::~HttpServletContextEx()
{
}
 
void HttpServletContextEx::initRequest(
        size_t nMaxContentLength
        ) __DCL_THROWS1(FormDataException*)
{
    if (__context->pszQueryString)
        HttpQueryStringDecoder::decode(
            ByteString(__context->pszQueryString),
            __queryMap
            );
 
    HttpCookieDecoder::decode(getHttpHeader("Cookie"), __cookieMap);
 
    if (methodNo() == HTTP_METHOD_POST) {
        addHeader(HttpHeader(L"Cache-Control", L"no-cache"));
            
        size_t nLength = contentLength();
        if (nLength && (nMaxContentLength == 0 || nLength <= nMaxContentLength)) {
            if (HttpQueryStringDecoder::isValidType(
                    __context->pszContentType)) {
                String str;
                ByteBuffer* buf = ByteBuffer::create(nLength);
                try {
                    size_t nRead = read(buf->data(), nLength);
                    buf->__dataLength = nRead;
                    *(buf->data() + buf->__dataLength) = L'\0';
                    ByteString s = buf;
                    buf->release();
                    __DCL_ASSERT(nRead == nLength);
                    
                    HttpQueryStringDecoder::decode(s, __formMap);
                }
                catch(IOException* e) {
                    buf->release();
                    throw e;
                }
            }
            else if (HttpFormDataDecoder::isValidType(__context->pszContentType)) {
                // multipart-formdata
                HttpInputStream input(this);
#if 0
                FileOutputStream output(__formFileMap.__tempDir + L"post.data", true);
                Files::copy(input, output);
#endif
                HttpFormDataDecoder decoder;
 
                decoder.decode(
                    input,
                    __context->pszContentType,
                    contentLength(),
                    __formMap,
                    __formFileMap
                    );
#ifdef __DCL_DEBUG
                if (!decoder.warnings().isEmpty()) {
                    __DCL_TRACE0(L"form-data decoding warnings\n");
                    __DCL_TRACE1(L"%ls\n", decoder.warnings().data());
                }
#endif
            }
            else {
                __DCL_TRACE1(L"Unknown Content-Type[%ls]\n", contentType().data());
                // unknown content-type
            }
        }
        
    }
}
 
StringWriter& HttpServletContextEx::writer()
{
    return __responseBuf;
}
 
IMPLEMENT_CLASSINFO(HttpServletEx, HttpServlet)
 
HttpServletEx::HttpServletEx()
{
    m_nMaxContentLength = 0; // unlimited
 
#ifdef __DCL_DEBUG
    m_bEnableDebugOut = true;
#endif
}
 
void HttpServletEx::onInitialize()
                    __DCL_THROWS1(Exception*)
{
    HttpServlet::onInitialize();
 
}
 
#define __WSTR(s) UTF8Decoder::decode(s, ByteString::length(s))
 
void HttpServletEx::onHttpService(
        const DCL_HTTP_SERVLET_CONTEXT* pContext
        ) __DCL_THROWS1(Exception*)
{
    String tempPath;
    if (__tempPath != NULL) {
        tempPath = __tempPath;
    }
 
    if (tempPath.isEmpty()) {
        String str = Files::dirname(__WSTR(pContext->pszScriptFilename));
        String str2 = str + L"temp/";
 
        if (Files::exists(str2))
            tempPath = str2;
        else
            tempPath = str;
    }
 
#ifdef __DCL_DEBUG
    StringWriter debugOut;
    Writer* pOldOut = NULL;
 
    // onService 내부에서 실수로 m_bEnableDebugOut 변경되는 것을 방지한다.
    bool bEnableDebugOut = m_bEnableDebugOut;
    if (bEnableDebugOut) {
        pOldOut = DCLDebugSetThreadReport(
                Thread::getCurrentThreadId(), 
                &debugOut
                );
    }
 
    HttpServletContextEx ctx(__SAPI, pContext, tempPath);
    try {
        __DCL_TRACE1(L"initRequest __tempDir[% ls]\n", tempPath.data());
        ctx.initRequest(m_nMaxContentLength);
        __DCL_TRACE1(L"onService __tempDir [%ls]\n", tempPath.data());
        onService(ctx);
        // setStatusCode가 호출되고 write가 단 한번도 호출되지 않은경우 
        // 실제 HTTP HEADER가 전송되지 않는다.
        // 헤더가 flush되지 않았으면 이를 전송한다.
        // onService 내부에서 ctx.flushHeader나 ctx.write를 명시적으로 
        // 호출하지 않은 상태에서 예외가 발생하면 다음은 실행되지 않을 것이다.
        ctx.flushHeader();
 
    }
    catch(Exception* e)    {
        if (pOldOut != NULL && debugOut.size() > 0) {
            // debugOut에 보관된 TRACE 데이터를 기본 디버그 스트림으로
            // 내보낸(flush) 후 예외를 다시 throw
            try {
                debugOut.flushTo(*pOldOut);
            }
            catch(Exception* e) {
                e->destroy();
            }
        }
 
        if (bEnableDebugOut) {
            DCLDebugSetThreadReport(
                Thread::getCurrentThreadId(),
                pOldOut
                );
        }
        throw e;
    }
 
    // 예외가 발생하지 않은 정상적인 상황
    if (bEnableDebugOut) {
        DCLDebugSetThreadReport(
            Thread::getCurrentThreadId(),
            pOldOut
            );
 
        if (pOldOut && debugOut.size() > 0) {
            // 서블릿의 onInitRequest, onService에서 생성한 TRACE의 출력을 파일로.. 
            pOldOut->write(debugOut.data(), debugOut.size());
        }
 
        if (/*ctx.m_pOutHtml
            && */!ctx.__contentType.compareNoCase(L"text", 4)
            && debugOut.size() > 0
            )
        {
            Writer& writer = ctx.writer();
            writer << L""
                "\n<hr>\n<div style=\"color: black; background-color: white;\">\n"
                "<h3>DCL Runtime Debugging Information</h3>\n"
                "<pre style=\"font-size:10pt;\">\n";
            debugOut.flushTo(writer);
            writer << L"</pre>\n</div>\n";
        }
    }
#else   // __DCL_DEBUG
 
    HttpServletContextEx ctx(__SAPI, pContext, tempPath);
 
    ctx.initRequest(m_nMaxContentLength);
    onService(ctx);
    // setStatusCode가 호출되고 write가 단 한번도 호출되지 않은경우 
    // 실제 HTTP HEADER가 전송되지 않는다.
    // 헤더가 flush되지 않았으면 이를 전송한다.
    // onService 내부에서 ctx.flushHeader나 ctx.write를 명시적으로 
    // 호출하지 않은 상태에서 예외가 발생하면 다음은 실행되지 않을 것이다.
    ctx.flushHeader();
#endif
 
    if (ctx.writer().size() > 0) {
        if (ctx.__contentType.compareNoCase(L"text/html", 9) == 0)
            ctx.writer() << L"</body>\n</html>\n";
 
        UTF8Encoder encoder(false);
        BytesOutputStream output;
        OutputStreamWriter writer(output, encoder);
 
        String content = ctx.writer().toString();
        writer.write(content.data(), content.length());
 
        ctx.addHeader(HttpHeader(L"Content-Length", String::valueOf(output.size())));
        HttpOutputStream out(&ctx);
        output.flushTo(out);
    }
}
 
__DCL_END_NAMESPACE