/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 <log4cxx/net/syslogappender.h>
#include <log4cxx/helpers/loglog.h>
#include <log4cxx/helpers/stringhelper.h>
#include <log4cxx/helpers/datagramsocket.h>
#include <log4cxx/spi/loggingevent.h>
#include <log4cxx/level.h>
#include <log4cxx/helpers/transcoder.h>
#if !defined(LOG4CXX)
    #define LOG4CXX 1
#endif
#include <log4cxx/private/log4cxx_private.h>

#if LOG4CXX_HAVE_SYSLOG
    #include <syslog.h>
#else
    /* facility codes */
    #define   LOG_KERN (0<<3)   /* kernel messages */
    #define   LOG_USER (1<<3)   /* random user-level messages */
    #define   LOG_MAIL (2<<3)   /* mail system */
    #define   LOG_DAEMON  (3<<3)   /* system daemons */
    #define   LOG_AUTH (4<<3)   /* security/authorization messages */
    #define   LOG_SYSLOG  (5<<3)   /* messages generated internally by syslogd */
    #define   LOG_LPR     (6<<3)   /* line printer subsystem */
    #define   LOG_NEWS (7<<3)   /* network news subsystem */
    #define   LOG_UUCP (8<<3)   /* UUCP subsystem */
    #define   LOG_CRON (9<<3)   /* clock daemon */
    #define   LOG_AUTHPRIV   (10<<3)  /* security/authorization messages (private) */
    #define   LOG_FTP     (11<<3)  /* ftp daemon */

    /* other codes through 15 reserved for system use */
    #define   LOG_LOCAL0  (16<<3)  /* reserved for local use */
    #define   LOG_LOCAL1  (17<<3)  /* reserved for local use */
    #define   LOG_LOCAL2  (18<<3)  /* reserved for local use */
    #define   LOG_LOCAL3  (19<<3)  /* reserved for local use */
    #define   LOG_LOCAL4  (20<<3)  /* reserved for local use */
    #define   LOG_LOCAL5  (21<<3)  /* reserved for local use */
    #define   LOG_LOCAL6  (22<<3)  /* reserved for local use */
    #define   LOG_LOCAL7  (23<<3)  /* reserved for local use */
#endif

#define LOG_UNDEF -1

using namespace log4cxx;
using namespace log4cxx::helpers;
using namespace log4cxx::net;

IMPLEMENT_LOG4CXX_OBJECT(SyslogAppender)

SyslogAppender::SyslogAppender()
    : syslogFacility(LOG_USER), facilityPrinting(false), sw(0)
{
    this->initSyslogFacilityStr();

}

SyslogAppender::SyslogAppender(const LayoutPtr& layout1,
                               int syslogFacility1)
    : syslogFacility(syslogFacility1), facilityPrinting(false), sw(0)
{
    this->layout = layout1;
    this->initSyslogFacilityStr();
}

SyslogAppender::SyslogAppender(const LayoutPtr& layout1,
                               const LogString& syslogHost1, int syslogFacility1)
    : syslogFacility(syslogFacility1), facilityPrinting(false), sw(0)
{
    this->layout = layout1;
    this->initSyslogFacilityStr();
    setSyslogHost(syslogHost1);
}

SyslogAppender::~SyslogAppender()
{
    finalize();
}

/** Release any resources held by this SyslogAppender.*/
void SyslogAppender::close()
{
    closed = true;

    if (sw != 0)
    {
        delete sw;
        sw = 0;
    }
}

void SyslogAppender::initSyslogFacilityStr()
{
    facilityStr = getFacilityString(this->syslogFacility);

    if (facilityStr.empty())
    {
        Pool p;
        LogString msg(LOG4CXX_STR("\""));
        StringHelper::toString(syslogFacility, p, msg);
        msg.append(LOG4CXX_STR("\" is an unknown syslog facility. Defaulting to \"USER\"."));
        LogLog::error(msg);
        this->syslogFacility = LOG_USER;
        facilityStr = LOG4CXX_STR("user:");
    }
    else
    {
        facilityStr += LOG4CXX_STR(":");
    }
}

/**
Returns the specified syslog facility as a lower-case String,
e.g. "kern", "user", etc.
*/
LogString SyslogAppender::getFacilityString(
    int syslogFacility)
{
    switch (syslogFacility)
    {
        case LOG_KERN:
            return LOG4CXX_STR("kern");

        case LOG_USER:
            return LOG4CXX_STR("user");

        case LOG_MAIL:
            return LOG4CXX_STR("mail");

        case LOG_DAEMON:
            return LOG4CXX_STR("daemon");

        case LOG_AUTH:
            return LOG4CXX_STR("auth");

        case LOG_SYSLOG:
            return LOG4CXX_STR("syslog");

        case LOG_LPR:
            return LOG4CXX_STR("lpr");

        case LOG_NEWS:
            return LOG4CXX_STR("news");

        case LOG_UUCP:
            return LOG4CXX_STR("uucp");

        case LOG_CRON:
            return LOG4CXX_STR("cron");
#ifdef LOG_AUTHPRIV

        case LOG_AUTHPRIV:
            return LOG4CXX_STR("authpriv");
#endif
#ifdef LOG_FTP

        case LOG_FTP:
            return LOG4CXX_STR("ftp");
#endif

        case LOG_LOCAL0:
            return LOG4CXX_STR("local0");

        case LOG_LOCAL1:
            return LOG4CXX_STR("local1");

        case LOG_LOCAL2:
            return LOG4CXX_STR("local2");

        case LOG_LOCAL3:
            return LOG4CXX_STR("local3");

        case LOG_LOCAL4:
            return LOG4CXX_STR("local4");

        case LOG_LOCAL5:
            return LOG4CXX_STR("local5");

        case LOG_LOCAL6:
            return LOG4CXX_STR("local6");

        case LOG_LOCAL7:
            return LOG4CXX_STR("local7");

        default:
            return LogString();
    }
}

int SyslogAppender::getFacility(
    const LogString& s)
{
    if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("KERN"), LOG4CXX_STR("kern")))
    {
        return LOG_KERN;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("USER"), LOG4CXX_STR("user")))
    {
        return LOG_USER;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("MAIL"), LOG4CXX_STR("mail")))
    {
        return LOG_MAIL;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("DAEMON"), LOG4CXX_STR("daemon")))
    {
        return LOG_DAEMON;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("AUTH"), LOG4CXX_STR("auth")))
    {
        return LOG_AUTH;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("SYSLOG"), LOG4CXX_STR("syslog")))
    {
        return LOG_SYSLOG;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LPR"), LOG4CXX_STR("lpr")))
    {
        return LOG_LPR;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("NEWS"), LOG4CXX_STR("news")))
    {
        return LOG_NEWS;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("UUCP"), LOG4CXX_STR("uucp")))
    {
        return LOG_UUCP;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("CRON"), LOG4CXX_STR("cron")))
    {
        return LOG_CRON;
    }

#ifdef LOG_AUTHPRIV
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("AUTHPRIV"), LOG4CXX_STR("authpriv")))
    {
        return LOG_AUTHPRIV;
    }

#endif
#ifdef LOG_FTP
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("FTP"), LOG4CXX_STR("ftp")))
    {
        return LOG_FTP;
    }

#endif
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL0"), LOG4CXX_STR("local0")))
    {
        return LOG_LOCAL0;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL1"), LOG4CXX_STR("local1")))
    {
        return LOG_LOCAL1;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL2"), LOG4CXX_STR("local2")))
    {
        return LOG_LOCAL2;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL3"), LOG4CXX_STR("local3")))
    {
        return LOG_LOCAL3;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL4"), LOG4CXX_STR("local4")))
    {
        return LOG_LOCAL4;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL5"), LOG4CXX_STR("local5")))
    {
        return LOG_LOCAL5;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL6"), LOG4CXX_STR("local6")))
    {
        return LOG_LOCAL6;
    }
    else if (StringHelper::equalsIgnoreCase(s, LOG4CXX_STR("LOCAL7"), LOG4CXX_STR("local7")))
    {
        return LOG_LOCAL7;
    }
    else
    {
        return LOG_UNDEF;
    }
}

void SyslogAppender::append(const spi::LoggingEventPtr& event, Pool& p)
{
    if  (!isAsSevereAsThreshold(event->getLevel()))
    {
        return;
    }

    LogString msg;
    layout->format(msg, event, p);

    // On the local host, we can directly use the system function 'syslog'
    // if it is available
#if LOG4CXX_HAVE_SYSLOG

    if (sw == 0)
    {
        std::string sbuf;
        Transcoder::encode(msg, sbuf);

        // use of "%s" to avoid a security hole
        ::syslog(syslogFacility | event->getLevel()->getSyslogEquivalent(),
                 "%s", sbuf.c_str());

        return;
    }

#endif

    // We must not attempt to append if sw is null.
    if (sw == 0)
    {
        errorHandler->error(LOG4CXX_STR("No syslog host is set for SyslogAppedender named \"") +
                            this->name + LOG4CXX_STR("\"."));
        return;
    }

    LogString sbuf(1, 0x3C /* '<' */);
    StringHelper::toString((syslogFacility | event->getLevel()->getSyslogEquivalent()), p, sbuf);
    sbuf.append(1, (logchar) 0x3E /* '>' */);

    if (facilityPrinting)
    {
        sbuf.append(facilityStr);
    }

    sbuf.append(msg);
    sw->write(sbuf);
}

void SyslogAppender::activateOptions(Pool&)
{
}

void SyslogAppender::setOption(const LogString& option, const LogString& value)
{
    if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SYSLOGHOST"), LOG4CXX_STR("sysloghost")))
    {
        setSyslogHost(value);
    }
    else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("FACILITY"), LOG4CXX_STR("facility")))
    {
        setFacility(value);
    }
    else
    {
        AppenderSkeleton::setOption(option, value);
    }
}

void SyslogAppender::setSyslogHost(const LogString& syslogHost1)
{
    if (this->sw != 0)
    {
        delete this->sw;
        this->sw = 0;
    }

    LogString slHost = syslogHost1;
    int slHostPort = -1;

    LogString::size_type colonPos = 0;
    colonPos = slHost.rfind(':');

    if (colonPos != LogString::npos)
    {
        slHostPort = StringHelper::toInt(slHost.substr(colonPos + 1));
        // Erase the :port part of the host name
        slHost.erase( colonPos );
    }

    // On the local host, we can directly use the system function 'syslog'
    // if it is available (cf. append)
#if LOG4CXX_HAVE_SYSLOG

    if (syslogHost1 != LOG4CXX_STR("localhost") && syslogHost1 != LOG4CXX_STR("127.0.0.1")
            && !syslogHost1.empty())
#endif
        if (slHostPort >= 0)
        {
            this->sw = new SyslogWriter(slHost, slHostPort);
        }
        else
        {
            this->sw = new SyslogWriter(slHost);
        }

    this->syslogHost = slHost;
    this->syslogHostPort = slHostPort;
}


void SyslogAppender::setFacility(const LogString& facilityName)
{
    if (facilityName.empty())
    {
        return;
    }

    syslogFacility = getFacility(facilityName);

    if (syslogFacility == LOG_UNDEF)
    {
        LogLog::error(LOG4CXX_STR("[") + facilityName +
                      LOG4CXX_STR("] is an unknown syslog facility. Defaulting to [USER]."));
        syslogFacility = LOG_USER;
    }

    this->initSyslogFacilityStr();
}