HttpServlet.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #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_HAVE_THIS_FILE__
#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    __pfnReportError;
    void*               __hErrorWriter;
    Writer*               __pAltOutput;
};
 
IMPLEMENT_CLASSINFO(ReportErrorWriter, Writer)
 
ReportErrorWriter::ReportErrorWriter(
    DCLHttpWriteStream    pfnErrorReport,
    void*               hErrorReport,
    Writer*       pAltOutput
)
{
    //Writer::__name = L"HttpReportErrorBridge";
 
    __pfnReportError = pfnErrorReport;
    __hErrorWriter = hErrorReport;
    __pAltOutput = pAltOutput;
}
 
Writer& ReportErrorWriter::write(const wchar_t* _buf, size_t _n)
    __DCL_THROWS1(IOException*)
{
    // 결코 예외를 발생 시키지 않는다.
    if (__pAltOutput) {
        try {
            __pAltOutput->write(_buf, _n);
        }
        catch(Exception* e) {
            e->destroy();
        }
    }
    __pfnReportError(__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* _buf,
    size_t _buflen
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_buflen <= INT32_MAX);
 
    if (!__SAPI->pfnReadClient(
            __context->hConn,
            _buf,
            &_buflen
        )) {
        throw new IOException(
            remoteAddr(),
            L"HTTP Connection error"
        );
    }
 
    return _buflen;
}
 
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* __debugFileOutput = 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
        __debugFileOutput   =
            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,
        __debugFileOutput
    );
 
    Writer* oldOutput =
        DCLDebugSetThreadReport(
            Thread::self(), 
            &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::self(), 
        oldOutput
    );
 
    if (!result && __debugFileOutput) {
        delete __debugFileOutput;
        __debugFileOutput = NULL;
    }
#endif
 
    return result;
}
 
bool HttpServlet::__cleanup(
    HttpServlet* _servlet,
    void* hErrorReport
)
{
#ifdef __DCL_DEBUG
    ReportErrorWriter output(
        _servlet->__SAPI->pfnReportError,
        hErrorReport,
        __debugFileOutput
    );
 
    Writer* oldOutput = DCLDebugSetThreadReport(
        Thread::self(), 
        &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
    oldOutput = DCLDebugSetThreadReport(
        Thread::self(),
        oldOutput
    );
 
    if (oldOutput != &output) {
        __DCL_TRACE0(L"Assertion Fail! 'oldOutput == &writer'\n");
    }
 
    if (__debugFileOutput) {
        delete __debugFileOutput;
        __debugFileOutput = 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,
        __debugFileOutput
    );
 
    Writer* oldOutput =
        DCLDebugSetThreadReport(
            Thread::self(), 
            &output
        );
 
    const void* pLastAllocPosition = 
        DCLDebugGetLastAllocPosition(
            Thread::self()
        );
#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::self(),
        pLastAllocPosition,
        DCL_ALLOC_DUMP_ALL,
        &output
    );
 
    DCLDebugSetThreadReport(
        Thread::self(), 
        oldOutput
    );
#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
*/