// Module:  Log4CPLUS

// File:    log4judpappender.cxx

// Created: 7/2012

// Author:  Siva Chandran P

//

//

// Copyright 2012 Siva Chandran P

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include "dcmtk/oflog/log4judp.h"

#include "dcmtk/oflog/layout.h"

#include "dcmtk/oflog/streams.h"

#include "dcmtk/oflog/logmacro.h"

#include "dcmtk/oflog/helpers/loglog.h"

#include "dcmtk/oflog/helpers/property.h"

#include "dcmtk/oflog/spi/logevent.h"

#include "dcmtk/oflog/internal/internal.h"

#include "dcmtk/oflog/thread/syncpub.h"

#include <iomanip>

#include <cstring>

#if defined (DCMTK_OFLOG_UNICODE)

#include <cwctype>

#else

#include <cctype>

#endif

namespace dcmtk

{

namespace log4cplus

{

namespace

{

static inline bool

is_control (tchar ch)

{

#if defined (DCMTK_OFLOG_UNICODE)

    return !! STD_NAMESPACE iswcntrl (STD_NAMESPACE char_traits<tchar>::to_int_type (ch));

#else

    return !! STD_NAMESPACE iscntrl (STD_NAMESPACE char_traits<tchar>::to_int_type (ch));

#endif

}

//! Outputs str with reserved XML characters escaped.

static

void

output_xml_escaped (tostream & os, tstring const & str)

{

    for (tstring::const_iterator it = str.begin (); it != str.end (); ++it)

    {

        tchar const & ch = *it;

        switch (ch)

        {

        case DCMTK_LOG4CPLUS_TEXT ('<'):

            os << DCMTK_LOG4CPLUS_TEXT ("&lt;");

            break;

        case DCMTK_LOG4CPLUS_TEXT ('>'):

            os << DCMTK_LOG4CPLUS_TEXT ("&gt;");

            break;

        case DCMTK_LOG4CPLUS_TEXT ('&'):

            os << DCMTK_LOG4CPLUS_TEXT ("&amp;");

            break;

        case DCMTK_LOG4CPLUS_TEXT ('\''):

            os << DCMTK_LOG4CPLUS_TEXT ("&apos;");

            break;

        case DCMTK_LOG4CPLUS_TEXT ('"'):

            os << DCMTK_LOG4CPLUS_TEXT ("&quot;");

            break;

        default:

            if (is_control (ch))

            {

                tchar const prev_fill = os.fill ();

                STD_NAMESPACE ios_base::fmtflags const prev_flags = os.flags ();

                os.flags (STD_NAMESPACE ios_base::hex | STD_NAMESPACE ios_base::right);

                os.fill (DCMTK_LOG4CPLUS_TEXT ('0'));

                os << STD_NAMESPACE setw (0) << DCMTK_LOG4CPLUS_TEXT ("&#x")

                    << STD_NAMESPACE setw (2) << STD_NAMESPACE char_traits<tchar>::to_int_type (ch)

                    << STD_NAMESPACE setw (0) << DCMTK_LOG4CPLUS_TEXT (";");

                os.fill (prev_fill);

                os.flags (prev_flags);

            }

            else

                os.put (ch);

        }

    }

}

//! Helper manipulator like class for escaped XML output.

struct outputXMLEscaped

{

    outputXMLEscaped (tstring const & s)

        : str (s)

    { }

    tstring const & str;

};

//! Overload stream insertion for outputXMLEscaped.

static

tostream &

operator << (tostream & os, outputXMLEscaped const & x)

{

    output_xml_escaped (os, x.str);

    return os;

}

} // namespace

//////////////////////////////////////////////////////////////////////////////

// Log4jUdpAppender ctors and dtor

//////////////////////////////////////////////////////////////////////////////

Log4jUdpAppender::Log4jUdpAppender(const tstring& host_, int port_)

    : socket()

    , host(host_)

    , port(port_)

{

    layout.reset (new PatternLayout (DCMTK_LOG4CPLUS_TEXT ("%m")));

    openSocket();

}

Unexecuted instantiation: dcmtk::log4cplus::Log4jUdpAppender::Log4jUdpAppender(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, int)

Unexecuted instantiation: dcmtk::log4cplus::Log4jUdpAppender::Log4jUdpAppender(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, int)

Log4jUdpAppender::Log4jUdpAppender(const helpers::Properties & properties)

    : Appender(properties)

    , socket()

    , host()

    , port(5000)

{

    host = properties.getProperty( DCMTK_LOG4CPLUS_TEXT("host"),

        DCMTK_LOG4CPLUS_TEXT ("localhost") );

    properties.getInt (port, DCMTK_LOG4CPLUS_TEXT ("port"));

    openSocket();

}

Unexecuted instantiation: dcmtk::log4cplus::Log4jUdpAppender::Log4jUdpAppender(dcmtk::log4cplus::helpers::Properties const&)

Unexecuted instantiation: dcmtk::log4cplus::Log4jUdpAppender::Log4jUdpAppender(dcmtk::log4cplus::helpers::Properties const&)

Log4jUdpAppender::~Log4jUdpAppender()

{

    destructorImpl();

}

//////////////////////////////////////////////////////////////////////////////

// Log4jUdpAppender public methods

//////////////////////////////////////////////////////////////////////////////

void

Log4jUdpAppender::close()

{

    helpers::getLogLog().debug(

        DCMTK_LOG4CPLUS_TEXT("Entering Log4jUdpAppender::close()..."));

    socket.close();

    closed = true;

}

//////////////////////////////////////////////////////////////////////////////

// Log4jUdpAppender protected methods

//////////////////////////////////////////////////////////////////////////////

void

Log4jUdpAppender::openSocket()

{

    if(!socket.isOpen()) {

        socket = helpers::Socket(host, OFstatic_cast(unsigned short, port), true);

    }

}

void

Log4jUdpAppender::append(const spi::InternalLoggingEvent& event)

{

    if(!socket.isOpen()) {

        openSocket();

        if(!socket.isOpen()) {

            helpers::getLogLog().error(

                DCMTK_LOG4CPLUS_TEXT("Log4jUdpAppender::append()- Cannot connect to server"));

            return;

        }

    }

    tstring & str = formatEvent (event);

    internal::appender_sratch_pad & appender_sp

        = internal::get_appender_sp ();

    tostringstream & buffer = appender_sp.oss;

    detail::clear_tostringstream (buffer);

    buffer << DCMTK_LOG4CPLUS_TEXT("<log4j:event logger=\"")

           << outputXMLEscaped (event.getLoggerName())

           << DCMTK_LOG4CPLUS_TEXT("\" level=\"")

           // TODO: Some escaping of special characters is needed here.

           << outputXMLEscaped (getLogLevelManager().toString(event.getLogLevel()))

           << DCMTK_LOG4CPLUS_TEXT("\" timestamp=\"")

           << event.getTimestamp().getFormattedTime(DCMTK_LOG4CPLUS_TEXT("%s%q"))

           << DCMTK_LOG4CPLUS_TEXT("\" thread=\"") << event.getThread()

           << DCMTK_LOG4CPLUS_TEXT("\">")

           << DCMTK_LOG4CPLUS_TEXT("<log4j:message>")

           // TODO: Some escaping of special characters is needed here.

           << outputXMLEscaped (str)

           << DCMTK_LOG4CPLUS_TEXT("</log4j:message>")

           << DCMTK_LOG4CPLUS_TEXT("<log4j:NDC>")

           // TODO: Some escaping of special characters is needed here.

           << outputXMLEscaped (event.getNDC())

           << DCMTK_LOG4CPLUS_TEXT("</log4j:NDC>")

           << DCMTK_LOG4CPLUS_TEXT("<log4j:locationInfo class=\"\" file=\"")

           // TODO: Some escaping of special characters is needed here.

           << outputXMLEscaped (event.getFile())

           << DCMTK_LOG4CPLUS_TEXT("\" method=\"")

           << outputXMLEscaped (event.getFunction())

           << DCMTK_LOG4CPLUS_TEXT("\" line=\"")

           << event.getLine()

           << DCMTK_LOG4CPLUS_TEXT("\"/>")

           << DCMTK_LOG4CPLUS_TEXT("</log4j:event>");

    DCMTK_LOG4CPLUS_TSTRING_TO_STRING (buffer.str ()).swap (appender_sp.chstr);

    bool ret = socket.write(appender_sp.chstr);

    if (!ret)

    {

        helpers::getLogLog().error(

            DCMTK_LOG4CPLUS_TEXT(

                "Log4jUdpAppender::append()- Cannot write to server"));

    }

}

} // namespace log4cplus

} // end namespace dcmtk