HttpServlet.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
 
#ifdef __DCL_DEBUG
#include <dcl/Thread.h>
#endif
 
#include <dcl/Files.h>
#include <dcl/Writer.h>
#include <dcl/Exception.h>
 
#include <dcl/HttpServlet.h>
#include <dcl/Charset.h>
#include <dcl/XFileWriter.h>
#include <dcl/Writer.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t* __THIS_FILE__ = __T("dcl/HttpServlet.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
class ReportErrorWriter : public Writer
{
    DECLARE_CLASSINFO(ReportErrorWriter)
public :
    ReportErrorWriter(
        DCLHttpWriteStream    pfnErrorReport,
        void*               hErrorReport,
        Writer*       pAltOutput
        );
 
    virtual Writer& write(const wchar_t* _buf, size_t _n)
            __DCL_THROWS1(IOException*);
 
private:
    DCLHttpWriteStream    m_pfnReportError;
    void*               m_hErrorWriter;
    Writer*               m_pAltOutput;
};
 
IMPLEMENT_CLASSINFO(ReportErrorWriter, Writer)
 
ReportErrorWriter::ReportErrorWriter(
        DCLHttpWriteStream    pfnErrorReport,
        void*               hErrorReport,
        Writer*       pAltOutput
        )
{
    //Writer::__name = L"HttpReportErrorBridge";
 
    m_pfnReportError = pfnErrorReport;
    m_hErrorWriter = hErrorReport;
    m_pAltOutput = pAltOutput;
}
 
Writer& ReportErrorWriter::write(const wchar_t* _buf, size_t _n)
            __DCL_THROWS1(IOException*)
{
    // 결코 예외를 발생 시키지 않는다.
    if (m_pAltOutput)
    {
        try
        {
            m_pAltOutput->write(_buf, _n);
        }
        catch(Exception* e)
        {
            e->destroy();
        }
    }
    m_pfnReportError(m_hErrorWriter, (const char*)_buf, _n);
    return *this;
}
 
IMPLEMENT_CLASSINFO(HttpServletContext, Object)
 
HttpServletContext::HttpServletContext(
        const DCL_HTTP_SERVER_API* _SAPI,
        const DCL_HTTP_SERVLET_CONTEXT* _context
        )
{
    __DCL_ASSERT(_SAPI != NULL);
    __DCL_ASSERT(_context != NULL);
    __DCL_ASSERT(_context->pszRemoteAddr != NULL);
 
    __statusCode = HTTP_STATUS_OK;
    __headerFlushed = false;
 
    __SAPI = _SAPI;
    __context = _context;
}
 
HttpServletContext::~HttpServletContext()
{
}
 
ByteString HttpServletContext::getHttpHeader(
        const char* _name   // = NULL
        ) const
{
    size_t len = 256;
    if (!_name) {
        len = 2048;
    }
 
    ByteBuffer* buf = ByteBuffer::create(len);
    if (!__SAPI->pfnGetRequestHeader(
                __context->hConn,
                _name,
                buf->data(),
                &len))  {
        if (len > 0) {
            // insufficient buffer
            ByteBuffer::extend(buf, len);
            __DCL_VERIFY(__SAPI->pfnGetRequestHeader(
                    __context->hConn,
                    _name,
                    buf->data(),
                    &len) != FALSE);
        }
    }
 
    __DCL_ASSERT(len <= buf->__allocLength);
    *(buf->data() + len) = '\0';
    buf->__dataLength = len;
 
    ByteString r = buf;
    buf->release();
    return r;
}
 
ByteString HttpServletContext::getCgiVariable(
        const char* _name   // = NULL
        ) const
{
    size_t len = 256;
    if (!_name) {
        len = 2048;
    }
 
    ByteBuffer* buf = ByteBuffer::create(len);
    if (!__SAPI->pfnGetCgiVariable(
                __context->hConn,
                _name,
                buf->data(),
                &len
                )) {
        if (len > 0) {
            // insufficient buffer
            ByteBuffer::extend(buf, len);
            __DCL_VERIFY(__SAPI->pfnGetCgiVariable(
                    __context->hConn,
                    _name,
                    buf->data(),
                    &len) != FALSE);
        }
    }
    
    __DCL_ASSERT(len <= buf->__allocLength);
    *(buf->data() + len) = '\0';
    buf->__dataLength = len;
 
    ByteString r = buf;
    buf->release();
    return r;
}
 
String HttpServletContext::getHttpHeader(
        const wchar_t* _name    // = NULL
        ) const
{
    if (_name) {
        return AsciiDecoder::decode(
            HttpServletContext::getHttpHeader(
                AsciiEncoder::encode(_name, (size_t)-1)
            )
        );
    }
    else {
        return AsciiDecoder::decode(
            HttpServletContext::getHttpHeader((const char*)NULL)
        );
    }
}
 
String HttpServletContext::getCgiVariable(
        const wchar_t* _name    // = NULL
        ) const
{
    if (_name) {
        return UTF8Decoder::decode(
            HttpServletContext::getCgiVariable(
                UTF8Encoder::encode(_name, (size_t)-1)
            )
        );
    }
    else {
        return UTF8Decoder::decode(
            HttpServletContext::getCgiVariable((const char*)NULL)
        );
    }
}
 
size_t HttpServletContext::read(
                void* pv,
                size_t n
                ) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(n <= INT32_MAX);
 
    if (!__SAPI->pfnReadClient(
            __context->hConn,
            pv,
            &n
            )) {
        throw new IOException(
                    remoteAddr(),
                    L"HTTP Connection error"
                    );
    }
        
    return n;
}
 
void HttpServletContext::setStatusCode(unsigned int uHttpStatusCode)
{
    __DCL_ASSERT(__context != NULL);
    __statusCode = uHttpStatusCode;
    if (uHttpStatusCode == HTTP_STATUS_NOT_FOUND)
        setContentType(L"text/html");
}
 
 
void HttpServletContext::setContentType(const wchar_t* _contentType, const wchar_t* pszCharset /* = NULL */)
{
    __DCL_ASSERT(__context != NULL);
 
    __DCL_ASSERT(_contentType != NULL);
    __contentType = _contentType;
    if (pszCharset) {
        __contentType = __contentType + L"; ";
        if (pszCharset) {
            __contentType = __contentType + L"charset=";
            __contentType = __contentType + pszCharset;
        }
    }
}
 
void HttpServletContext::addHeader(const HttpHeader& httpHeader)
{
    __DCL_ASSERT(__context != NULL);
 
    if (!httpHeader.name().compareNoCase(L"Content-Type"))
        __contentType = httpHeader.content();
    else
        __responseHeaders += httpHeader.toString() + L"\r\n";
}
 
void HttpServletContext::flushHeader()
{
    __DCL_ASSERT(__context != NULL);
 
    if (__headerFlushed)
        return;
 
    if (!__contentType.isEmpty()) {
        __responseHeaders += L"Content-Type: ";
        __responseHeaders += __contentType + L"\r\n";
    }
 
    __responseHeaders += L"\r\n";
 
    ByteString s = UTF8Encoder::encode(__responseHeaders.toString());
 
    __SAPI->pfnSendResponseHeader(
            __context->hConn,
            __statusCode,
            s.data(),
            s.length()
            );
 
    __headerFlushed = true;
}
 
void HttpServletContext::write(
            const void* pv,
            size_t n
            ) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(n <= INT32_MAX);
    __DCL_ASSERT(__context != NULL);
 
    if (!__headerFlushed)
        flushHeader();
 
    size_t len = n;
    if (!__SAPI->pfnWriteClient(
            __context->hConn,
            pv,
            &len
            )) {
        throw new IOException(
                    remoteAddr(),
                    L"http connection error"
                    );
    }
 
    __DCL_TRACE2(L"pfnWriteClient [%zd] [%zd]\n", n, len);  
}
 
IMPLEMENT_CLASSINFO(HttpServlet, Object)
 
HttpServlet::HttpServlet()
{
    __configPath = NULL;
    __tempPath = NULL;
    __SAPI = NULL;
}
 
String HttpServlet::getIniFileName(
                const wchar_t* _basename    // = NULL
                ) const
{
    String basename;
 
    if (_basename) {
        __DCL_ASSERT(*_basename != '\0');
        basename = _basename;
    }
    else {
        basename = Files::basename(__moduleName);
        size_t index = basename.lastIndexOf('.');
        if (index != (size_t) -1) {
            __DCL_ASSERT(index > 0);
            basename = basename.left(index);
        }
        basename = basename + L".ini";
    }
 
    if (__configPath) {
        String path = __configPath;
        if (!path.endsWith(L"/")) {
            path = path + L'/';
        }
        path = path + basename;
        if (Files::exists(path)) {
            return path;
        }
 
    }
 
    String dir = Files::dirname(__moduleName);
    if (!dir.endsWith(L"/")) {
        dir = dir + L'/';
    }
    return dir + basename;
}
 
void HttpServlet::onInitialize()
                    __DCL_THROWS1(Exception*)
{
}
 
void HttpServlet::onCleanup()
                    __DCL_THROWS1(Exception*)
{
}
 
// DCL_HTTP_SERVLET member function Helper
#ifdef __DCL_DEBUG
static XFileWriter* __pDebugFileOut = NULL;
#endif
bool HttpServlet::__initialize(
        HttpServlet* _servlet,
        const DCL_HTTP_SERVLET_CONFIG* _config,
        void* hErrorReport
        )
{
#ifdef __DCL_DEBUG
    __DCL_ASSERT(_config != NULL
        && _config->pszModuleName != NULL
        && *(_config->pszModuleName) != L'\0'
    );
    __DCL_ASSERT(_config->pSAPI != NULL);
#endif
 
    _servlet->__moduleName = _config->pszModuleName;
    _servlet->__configPath = _config->pszConfigPath;
    _servlet->__tempPath = _config->pszTempPath;
    _servlet->__SAPI = _config->pSAPI;
 
#ifdef __DCL_DEBUG
    String filename = _servlet->__moduleName;
    filename = filename.left(filename.lastIndexOf(L'.')) + L".dump.txt";
    try {
        // Mutexted FileWriter
        __pDebugFileOut =
            new XFileWriter(filename, false, new UTF8Encoder());
    }
    catch(IOException* e) {
        __DCL_TRACE2(
            L"Warning! dump file create fail. [%ls]: [%ls]\n",
            filename.data(),
            e->toString().data()
            );
        e->destroy();
    }
#endif
 
#ifdef __DCL_DEBUG
    ReportErrorWriter output(
        _servlet->__SAPI->pfnReportError,
        hErrorReport,
        __pDebugFileOut
        );
 
    Writer* pOldOutput =
        DCLDebugSetThreadReport(
            Thread::getCurrentThreadId(), 
            &output
            );
 
#else
    ReportErrorWriter output(
            _servlet->__SAPI->pfnReportError,
            hErrorReport,
            NULL
            );
#endif
 
    bool result = TRUE;
    try {
        __DCL_TRACE1(L"begin __initialize [%ls]\n", _servlet->__moduleName);
        _servlet->onInitialize();
        __DCL_TRACE1(L"end __initialize [%ls]\n", _servlet->__moduleName);
    }
    catch (Exception* _e) {
        output << _e->toStringAll() << endl;
        _e->destroy();
        result = FALSE;
    }
    
#ifdef __DCL_DEBUG
    DCLDebugSetThreadReport(
            Thread::getCurrentThreadId(), 
            pOldOutput
            );
 
    if (!result && __pDebugFileOut) {
        delete __pDebugFileOut;
        __pDebugFileOut = NULL;
    }
#endif
 
    return result;
}
 
bool HttpServlet::__cleanup(
        HttpServlet* _servlet,
        void* hErrorReport
        )
{
#ifdef __DCL_DEBUG
    ReportErrorWriter output(
        _servlet->__SAPI->pfnReportError,
        hErrorReport,
        __pDebugFileOut
        );
 
    Writer* pOldOutput = pOldOutput =
        DCLDebugSetThreadReport(
            Thread::getCurrentThreadId(), 
            &output
            );
 
#else
    ReportErrorWriter output(
        _servlet->__SAPI->pfnReportError,
        hErrorReport,
        NULL
        );
#endif
 
    bool result = TRUE;
    try {
        __DCL_TRACE1(L"begin __cleanup [%ls]\n", _servlet->__moduleName);
        _servlet->onCleanup();
        __DCL_TRACE1(L"end __cleanup [%ls]\n", _servlet->__moduleName);
    }
    catch (Exception* e) {
        output << e->toStringAll() << endl;
        e->destroy();
        result = FALSE;
    }
 
#ifdef __DCL_DEBUG
    pOldOutput = DCLDebugSetThreadReport(
                        Thread::getCurrentThreadId(),
                        pOldOutput
                        );
 
    if (pOldOutput != &output) {
        __DCL_TRACE0(L"Assertion Fail! 'pOldOutput == &writer'\n");
    }
 
    if (__pDebugFileOut) {
        delete __pDebugFileOut;
        __pDebugFileOut = NULL;
    }
#endif
 
    return result;
}
 
bool HttpServlet::__httpService(
        HttpServlet* _servlet,
        const DCL_HTTP_SERVLET_CONTEXT* _context,
        void* hErrorReport
        )
{
#ifdef __DCL_DEBUG
    ReportErrorWriter output(
        _servlet->__SAPI->pfnReportError,
        hErrorReport,
        __pDebugFileOut
        );
 
    Writer* pOldOutput =
        DCLDebugSetThreadReport(
            Thread::getCurrentThreadId(), 
            &output
            );
 
    const void* pLastAllocPosition = 
        DCLDebugGetLastAllocPosition(
            Thread::getCurrentThreadId()
        );
#else
    ReportErrorWriter output(
        _servlet->__SAPI->pfnReportError,
        hErrorReport,
        NULL
        );
#endif
 
    bool result = TRUE;
    try {
        __DCL_TRACE1(L"begin __httpService [%ls]\n", _servlet->__moduleName);
        _servlet->onHttpService(_context);
        __DCL_TRACE1(L"end __httpService [%ls]\n", _servlet->__moduleName);
    }
    catch (Exception* e) {
        String s = e->toStringAll();
        __DCL_TRACE2(L"catch __httpService [%ls][%ls]\n", _servlet->__moduleName,
            s.data());
        output << s << endl;
        e->destroy();
        result = FALSE;
    }
 
#ifdef __DCL_DEBUG
    DCLDebugDumpThreadMemoryLeak(
        Thread::getCurrentThreadId(),
        pLastAllocPosition,
        DCL_ALLOC_DUMP_ALL,
        &output
    );
 
    DCLDebugSetThreadReport(
        Thread::getCurrentThreadId(), 
        pOldOutput
        );
#endif
 
    return result;
}
 
#define __WSTR(s) s ? UTF8Decoder::decode(s, ByteString::length(s)) : String()
 
String HttpServletContext::remoteAddr() const
{
    __DCL_ASSERT(__context != NULL);
    return __WSTR(__context->pszRemoteAddr);
}
 
unsigned int HttpServletContext::remotePort() const
{
    __DCL_ASSERT(__context != NULL);
    return __context->uRemotePort;
}
 
String HttpServletContext::method() const
{
    __DCL_ASSERT(__context != NULL);
    return __WSTR(__context->pszRequestMethod);
}
 
unsigned int HttpServletContext::methodNo() const
{
    __DCL_ASSERT(__context != NULL);
    return __context->uRequestMethod;
}
 
String HttpServletContext::path() const
{
    __DCL_ASSERT(__context != NULL);
    return __WSTR(__context->pszPath);
}
 
String HttpServletContext::queryString() const
{
    __DCL_ASSERT(__context != NULL);
    return __WSTR(__context->pszQueryString);
}
 
String HttpServletContext::contentType() const
{
    __DCL_ASSERT(__context != NULL);
    return __WSTR(__context->pszContentType);
}
 
size_t HttpServletContext::contentLength() const
{
    __DCL_ASSERT(__context != NULL);
    return __context->uContentLength;
}
 
String HttpServletContext::scriptFilename() const
{
    __DCL_ASSERT(__context != NULL);
    return __WSTR(__context->pszScriptFilename);
}
 
String HttpServletContext::scriptData() const
{
    __DCL_ASSERT(__context != NULL);
    return String(__context->pszScriptData,
        __context->uScriptLength);
}
 
const String& HttpServletContext::resContentType() const
{
    return __contentType;
}
 
__DCL_END_NAMESPACE
/*
#if defined(_WINDOWS) && defined(_USRDLL)
bool APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
        case DLL_PROCESS_ATTACH:
            __DCL_TRACE0("DCLHExtd.dll DLL_PROCESS_ATTACH\n");
            break;
        case DLL_PROCESS_DETACH:
            __DCL_TRACE0("DCLHExtd.dll DLL_PROCESS_DETACH\n");
            break;
        case DLL_THREAD_ATTACH:
            __DCL_TRACE0("DCLHExtd.dll DLL_THREAD_ATTACH\n");
            break;
        case DLL_THREAD_DETACH:
            __DCL_TRACE0("DCLHExtd.dll DLL_THREAD_DETACH\n");
            break;
    }
    return TRUE;
}
#endif
*/