/* 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 <stdint.h>
#include <ap_config.h>
#include "ap_mpm.h"
#include "ap_provider.h"
#include <http_core.h>
#include <httpd.h>
#include <http_log.h>
#include <apr_version.h>
#include <apr_pools.h>
#include <apr_strings.h>
#include "unixd.h"
#include "scoreboard.h"
#include "mpm_common.h"
#include "mod_log_config.h"

#define SD_JOURNAL_SUPPRESS_LOCATION 1

#include "systemd/sd-journal.h"

#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif

#define MAX_ENTRIES 15

static int journald_info_get_priority(int level)
{
    switch(level) {
        /* We don't use EMERG here, because journald broadcasts EMERG messages
         * to all terminals. APLOG_EMERG is usually not used in this context.
         * in httpd code. */
        case APLOG_EMERG:   return LOG_ALERT;
        case APLOG_ALERT:   return LOG_ALERT;
        case APLOG_CRIT:    return LOG_CRIT;
        case APLOG_ERR:     return LOG_ERR;
        case APLOG_WARNING: return LOG_WARNING;
        case APLOG_NOTICE:  return LOG_NOTICE;
        case APLOG_INFO:    return LOG_INFO;
        case APLOG_DEBUG:   return LOG_DEBUG;
        case -1:            return LOG_INFO;
        default:            return LOG_DEBUG;
    }
    return LOG_INFO;
}

static apr_pool_t *journald_info_get_pool(const ap_errorlog_info *info)
{
    if (info->r && info->r->pool)
        return info->r->pool;
    if (info->c && info->c->pool)
        return info->c->pool;
    if (info->pool)
        return info->pool;
    if (info->s && info->s->process && info->s->process->pool)
        return info->s->process->pool;
    return 0;
}

static apr_status_t iovec_add_entry(apr_pool_t *pool, struct iovec *iov,
                                    const char *format, int len, ...)
{
    va_list ap;
    va_start(ap, len);
    iov->iov_base = apr_pvsprintf(pool, format, ap);
    va_end(ap);
    if (!iov->iov_base) {
        return APR_ENOMEM;
    }
    if (len < 0) {
        iov->iov_len = strlen(iov->iov_base);
    }
    else {
        iov->iov_len = len;
    }
    return APR_SUCCESS;
}

static void journald_log(apr_pool_t *pool, const char *log,
                         const char *errstr, int len, int priority,
                         const server_rec *s, const request_rec *r)
{
    apr_pool_t *subpool;
    apr_status_t rv = APR_SUCCESS;
    struct iovec iov[MAX_ENTRIES];
    int iov_size = 0;

    if (apr_pool_create(&subpool, pool) != APR_SUCCESS) {
        /* We were not able to create subpool, log at least what we have. */
        sd_journal_send("MESSAGE=%s", errstr, "LOG=%s", log,
                    "PRIORITY=%i", priority,
                    NULL);
        return;
    }

    /* Adds new entry to iovec if previous additions were successful. */
#define IOVEC_ADD_LEN(FORMAT, VAR, LEN) \
    if (rv == APR_SUCCESS && iov_size < MAX_ENTRIES) { \
        rv = iovec_add_entry(subpool, &iov[iov_size], FORMAT, LEN, VAR); \
        if (rv == APR_SUCCESS) \
            iov_size++; \
    }
#define IOVEC_ADD(FORMAT, VAR) IOVEC_ADD_LEN(FORMAT, VAR, -1)

    IOVEC_ADD_LEN("MESSAGE=%s", errstr, len + 8);
    IOVEC_ADD("LOG=%s", log);
    IOVEC_ADD("PRIORITY=%i", priority);

    if (s) {
        IOVEC_ADD("SERVER_HOSTNAME=%s", s->server_hostname);
    }

    if (r) {
        IOVEC_ADD("REQUEST_HOSTNAME=%s", r->hostname);
        IOVEC_ADD("REQUEST_USER=%s", r->user ? r->user : "");
        IOVEC_ADD("REQUEST_URI=%s", r->uri ? r->uri : "");
        IOVEC_ADD("REQUEST_USERAGENT_IP=%s", r->useragent_ip);
    }

    sd_journal_sendv(iov, iov_size);
    apr_pool_destroy(subpool);
}

static void *journald_error_log_init(apr_pool_t *p, server_rec *s)
{
    void *success = (void *)p; /* anything non-NULL is success */
    return success;
}

static apr_status_t journald_error_log(const ap_errorlog_info *info,
                                       void *handle, const char *errstr,
                                       apr_size_t len)
{
    const server_rec *s = info->s;
    const request_rec *r = info->r;
    apr_pool_t *pool;
    const char *log_name = (s && s->error_fname && *s->error_fname) ?
                            s->error_fname : "error_log";

    pool = journald_info_get_pool(info);
    if (!pool) {
        /* We don't have any pool, so at least log the message without
         * any additional data. */
        sd_journal_send("MESSAGE=%s", errstr, "LOG=%s", "log_name",
                    "PRIORITY=%i", journald_info_get_priority(info->level),
                    NULL);
        return APR_SUCCESS;
    }

    journald_log(pool, log_name, errstr, len,
                 journald_info_get_priority(info->level), s, r);

    return APR_SUCCESS;
}

static const char *journald_error_log_parse(cmd_parms *cmd, const char *arg)
{
    return NULL;
}

static void journald_register_hooks(apr_pool_t *p)
{
    static const ap_errorlog_provider journald_provider = {
        &journald_error_log_init,
        &journald_error_log,
        &journald_error_log_parse,
        0
    };

    ap_register_provider(p, AP_ERRORLOG_PROVIDER_GROUP, "journald",
                         AP_ERRORLOG_PROVIDER_VERSION,
                         &journald_provider);
}

AP_DECLARE_MODULE(journald) =
{
    STANDARD20_MODULE_STUFF,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    journald_register_hooks,
};