/*
**  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 <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "l2.h"

#define HAVE_INET_ATON
#ifndef HAVE_INET_PTON
#ifdef  HAVE_INET_ATON

/******************************************************************
IPv4 source used from Unix Network Programming by Richard STEVENS
 ******************************************************************/
static int inet_pton(int iFamily, const char *pszAddress, void *pvMemref)
{
    int             i    = 0;
    struct in_addr  IP4Addr;
    struct in6_addr IP6Addr;
    char            *pszIndex     = NULL;    /* To index IPv6 validity */
    char            *pszNextfield = NULL;    /* For IPv6 address trans */

    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) /* If we are translating IPv6 addresses     */
    {                             /* the user needs to use precise notation   */
        pszIndex = malloc(strlen(pszAddress));
        strcpy(pszIndex, pszAddress);           /* Initialize, verify in loop */
        for (i = 0; i < 8; i++)    /* Iterate through the IPv6 address fields */
        {
            IP6Addr.__u6_addr.__u6_addr16[i] =\
                ntohs((u_int16_t)strtol(pszIndex, &pszNextfield, 16));
            if ((pszNextfield == '\0') ||\
               ((pszNextfield - pszIndex) != (4 * sizeof(char))))
            {
                return 0; /* User is supplying a IPv6 format we don't support */
            }

            pszIndex = ++pszNextfield;
        }

        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
{
    int iFamily;             /* IP version to use, AF_INET4 or AF_INET6  */
    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 l2_result_t hook_create(l2_context_t *ctx, l2_channel_t *ch)
{
    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_ERR_MEM;

    /* 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 l2_result_t hook_configure(l2_context_t *ctx, l2_channel_t *ch, const char *fmt, va_list ap)
{
    l2_ch_socket_t *cfg;
    l2_param_t pa[4];
    l2_result_t rv;

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

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

    return rv;
}

/* open channel */
static l2_result_t hook_open(l2_context_t *ctx, l2_channel_t *ch)
{
    l2_ch_socket_t      *cfg;
    struct hostent      *pHostentry;
    struct sockaddr_in  IP4Sockaddr;
    struct sockaddr_in6 IP6Sockaddr;
    struct in6_addr     *IP6Addr;

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

    /* open channel socket      */
    if (cfg->iFamily == AF_INET) /* IPv4 */
    {
        /* resolve host numerically */
        if (inet_pton(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
                return L2_ERR_USE; /* what?? we specify IPv4 when it is not? */
        }

        else /* host string was not parsable for some reason */
            return L2_ERR_SYS;

        if ((cfg->iSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
            return L2_ERR_SYS;

        if (connect(cfg->iSocket, (struct sockaddr *)&IP4Sockaddr, sizeof(IP4Sockaddr)))
        {
            close(cfg->iSocket);
            return L2_ERR_SYS;
        }

        return L2_OK; /* we are connected */
    }

    else if (cfg->iFamily == AF_INET6) /* IPv6 */
    {
        /* resolve host numerically */
        if (inet_pton(AF_INET6, cfg->pszHost, &IP6Sockaddr.sin6_addr.s6_addr) == 1)
        {
            IP6Sockaddr.sin6_family = AF_INET6;
            IP6Sockaddr.sin6_port   = htons(cfg->iPort);
        }

        /* resolve host nominally */
        else if (pHostentry = gethostbyname(cfg->pszHost) != NULL)
        {
            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_ERR_USE; /* what?? we specify IPv6 when it is not? */
        }

        else /* host string was not parsable for some reason */
            return L2_ERR_SYS;

        if ((cfg->iSocket = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP)) == -1)
            return L2_ERR_SYS;

        if (connect(cfg->iSocket, (struct sockaddr *)&IP6Sockaddr, sizeof(IP6Sockaddr)))
        {
            close(cfg->iSocket);
            return L2_ERR_SYS;
        }

        return L2_OK; /* we are connected */
    }

    return L2_ERR_USE;
}

/* write to channel */
static l2_result_t hook_write(l2_context_t *ctx, l2_channel_t *ch, 
                      const char *buf, size_t buf_size)
{
    l2_ch_socket_t *cfg;
    size_t          sizeWrite;
    size_t          sizeRemain;

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

    /* write message to channel socket, but check to make   */
    /* sure that the whole message was successfully written */
    sizeWrite  = 0;
    sizeRemain = buf_size;
    while(sizeRemain)
    {
        sizeWrite  = send(cfg->iSocket, buf + sizeWrite, sizeRemain, 0);
        sizeRemain = sizeRemain - sizeWrite; /* how much is left? */

        if (sizeWrite == -1)
            return L2_ERR_SYS;
    }

    return L2_OK;
}

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

    return L2_OK;
}

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

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

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

    return L2_OK;
}

/* destroy channel */
static l2_result_t hook_destroy(l2_context_t *ctx, l2_channel_t *ch)
{
    /* parameter checks */
    if (ctx->vp == NULL) 
        return L2_ERR_ARG;

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

    return L2_OK;
}

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