/*
**  L2 - OSSP Logging Library
**  Copyright (c) 2001 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001 Cable & Wireless Deutschland (http://www.cw.com/de/)
**
**  This file is part of OSSP L2, a flexible logging library which
**  can be found at http://www.ossp.org/pkg/l2/.
**
**  Permission to use, copy, modify, and distribute this software for
**  any purpose with or without fee is hereby granted, provided that
**  the above copyright notice and this permission notice appear in all
**  copies.
**
**  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
**  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
**  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
**  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
**  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
**  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
**  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
**  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
**  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
**  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
**  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
**  SUCH DAMAGE.
**
**  l2_ch_socket.c: socket channel implementation
*/

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>

#include "l2.h"
#include "l2_p.h"

#define HAVE_INET_ATON
#ifndef HAVE_INET_PTON
#ifdef HAVE_INET_ATON
/* !!! TODO change pton1 to pton !!! */
static int inet_pton1(int iFamily, const char *pszAddress, void *pvMemref)
{
    int             i    = 0;
    struct in_addr  IP4Addr;
    struct in6_addr IP6Addr;
    char            *pszNextfield = NULL;          /* For IPv6 address trans */
    char            **ppszVerify  = &pszNextfield; /* To check IPv6 validity */

    if (iFamily == AF_INET)
    {
        if (inet_aton(pszAddress, &IP4Addr))
        {
            memcpy(pvMemref, &IP4Addr, sizeof(struct in_addr));
            return 1;
        }
        return 0;
    }

    else if (iFamily == AF_INET6)
    {
        for (i = 0; i < 16; i++)   /* Iterate through the IPv6 address fields */
        {
            ppszVerify = &pszNextfield;  /* Reset and compare later to verify */
            IP6Addr.__u6_addr.__u6_addr8[i] = (u_int8_t)strtol(pszAddress,\
                &pszNextfield, 16);
            *pszNextfield++; /* !!! TODO Problema !!! */

            if ((&pszNextfield - ppszVerify) != 2)
                return 0; /* User is supplying a IPv6 format we don't support */
        }
        memcpy(pvMemref, &IP6Addr, sizeof(struct in6_addr));
        return 1;
    }

    else      /* User converting from an address family that we don't support */
    {
        errno = EAFNOSUPPORT;
        return -1;
    }
}
#else
#error "neither inet_pton nor inet_aton available"
#endif
#endif

/* declare private channel configuration */
typedef struct
{
    char *pszHost;           /* IP Address or name of host to connect to */
    int iPort;               /* TCP Port to connect to                   */
    int iSocket;             /* Socket descriptor used during writing    */
} l2_ch_socket_t;

/* create channel */
static int hook_create(l2_context_t *ctx)
{
    l2_ch_socket_t *cfg = NULL;

    /* allocate private channel configuration */
    if ((cfg = (l2_ch_socket_t *)malloc(sizeof(l2_ch_socket_t))) == NULL)
        return L2_ERROR;

    /* initialize configuration with reasonable defaults */
    cfg->pszHost   = NULL;
    cfg->iPort     = 0;
    cfg->iSocket   = -1;

    /* link private channel configuration into channel context */
    ctx->vp = cfg;

    return L2_OK;
}

/* configure channel */
static int hook_configure(l2_context_t *ctx, const char *fmt, va_list ap)
{
    l2_ch_socket_t *cfg;
    l2_param_t pa[3];
    l2_result_t rv;

    /* parameter checks */
    if ((cfg = (l2_ch_socket_t *)ctx->vp) == NULL)
        return L2_ERROR;

    /* feed and call generic parameter parsing engine */
    L2_PARAM_SET(pa[0], host, CHARPTR, &cfg->pszHost);
    L2_PARAM_SET(pa[1], port, INT,     &cfg->iPort);
    L2_PARAM_END(pa[2]);
    rv = l2_channel_setparams(pa, fmt, ap);

    return rv;
}

/* open channel */
static int hook_open(l2_context_t *ctx, l2_channel_t *downstream)
{
    l2_ch_socket_t      *cfg;
    struct hostent      *pHostentry;
    struct sockaddr_in  IP4Sockaddr;
    struct sockaddr_in6 IP6Sockaddr;

    /* parameter checks */
    if ((cfg = (l2_ch_socket_t *)ctx->vp) == NULL)
        return L2_ERROR;
    if (cfg->pszHost == NULL)
        return L2_ERROR;

    /* open channel socket      */
    /* resolve host numerically */
    if (inet_pton1(AF_INET, cfg->pszHost, &IP4Sockaddr.sin_addr.s_addr) == 1)
    {
        IP4Sockaddr.sin_family = AF_INET;
        IP4Sockaddr.sin_port   = htons(cfg->iPort);
    }

    /* resolve host nominally   */
    else if ((pHostentry = gethostbyname(cfg->pszHost)) != NULL)
    {
        if (pHostentry->h_addrtype == AF_INET)
        {
            IP4Sockaddr.sin_family = AF_INET;
            IP4Sockaddr.sin_port   = htons(cfg->iPort);
            memcpy(&IP4Sockaddr.sin_addr.s_addr, pHostentry->h_addr_list[0],\
                sizeof(IP4Sockaddr.sin_addr.s_addr));
        }

        else if (pHostentry->h_addrtype == AF_INET6)
        {
            IP6Sockaddr.sin6_family = AF_INET6;
            IP6Sockaddr.sin6_port   = htons(cfg->iPort);
            memcpy(&IP6Sockaddr.sin6_addr.__u6_addr, pHostentry->h_addr_list[0],\
                sizeof(IP6Sockaddr.sin6_addr.__u6_addr));
        }
    }

    else
        return L2_ERROR;

    if ((cfg->iSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
        return L2_ERROR;
    if (connect(cfg->iSocket, (struct sockaddr *)&IP4Sockaddr, sizeof(IP4Sockaddr)))
    {
        close(cfg->iSocket);
        return L2_ERROR;
    }

    /* optionally open downstream channel, too */
    if (downstream != NULL)
        if (l2_channel_open(downstream) == L2_ERROR)
            return L2_ERROR;

    return L2_OK;
}

/* write to channel */
static int hook_write(l2_context_t *ctx, l2_channel_t *downstream, 
                      const char *buf, size_t buf_size)
{
    l2_ch_socket_t *cfg;

    /* parameter checks */
    if ((cfg = (l2_ch_socket_t *)ctx->vp) == NULL)
        return L2_ERROR;
    if (cfg->iSocket == -1)
        return L2_ERROR;

    /* write message to channel socket */
    if (send(cfg->iSocket, buf, buf_size, 0) == -1)
        return L2_ERROR;

    /* optionally write to downstream channel, too */
    if (downstream != NULL)
        if (l2_channel_write(downstream, buf, buf_size) == L2_ERROR)
            return L2_ERROR;

    return L2_OK;
}

/* flush channel */
static int hook_flush(l2_context_t *ctx, l2_channel_t *downstream)
{
    /* NOP for this channel, because Unix I/O sockets are unbuffered! */

    /* optionally flush downstream channel, too */
    if (downstream != NULL)
        if (l2_channel_flush(downstream) == L2_ERROR)
            return L2_ERROR;

    return L2_OK;
}

/* close channel */
static int hook_close(l2_context_t *ctx, l2_channel_t *downstream)
{
    l2_ch_socket_t *cfg;

    /* optionally close downstream channel, too */
    if (downstream != NULL)
        if (l2_channel_close(downstream) == L2_ERROR)
            return L2_ERROR;

    /* parameter checks */
    if ((cfg = (l2_ch_socket_t *)ctx->vp) == NULL)
        return L2_ERROR;
    if (cfg->iSocket == -1)
        return L2_ERROR;

    /* close channel socket */
    if ((shutdown(cfg->iSocket, SHUT_RDWR)) || (close(cfg->iSocket)))
        return L2_ERROR;

    return L2_OK;
}

/* destroy channel */
static int hook_destroy(l2_context_t *ctx)
{
    /* parameter checks */
    if (ctx->vp == NULL) 
        return L2_ERROR;

    /* destroy channel configuration */
    free(ctx->vp);

    return L2_OK;
}

/* exported channel handler structure */
l2_handler_t l2_handler_socket = {
    hook_create,
    hook_configure,
    hook_open,
    hook_write,
    hook_flush,
    hook_close,
    hook_destroy
};