/*
**  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_sockmon.c: Socket monitor for use with l2_test.c
*/

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>

#define BACKLOG 1024    /* max # pending connections */
#define BUFFSIZ 256     /* max string size           */

char *strcasedup(const char *pszIn)
{
    int  i        = 0;
    char *pszTemp = NULL;

/*    ASSERT(pszIn);*/
/*    ASSERT(*pszIn);*/

    if ((pszTemp = (char *)strdup(pszIn)) == NULL)
        return NULL;
    else
    {
        for (i = 0; *(pszTemp + i); i++)
            if (isupper(*(pszTemp + i)))
                *(pszTemp + i) = (char)tolower(*(pszTemp + i));
        return pszTemp;
    }
}

void dowork(int iSock)
{
    char pszBuf[BUFFSIZ];
    int  cc;

/*    ASSERT(iSock);*/

    while (1) { /* Exits when read finishes */
        cc = read(iSock, pszBuf, sizeof (pszBuf));
        if (cc == -1) {
            perror("read");
            exit(1);
        }

        if (cc == 0) {
            /* EOF */
            (void) close(iSock);
            (void) printf("Connection closed\n");
            return;
        }

        pszBuf[cc + 1] = '\0';
        (void) printf("Read: %s", pszBuf);

        if (write(iSock, pszBuf, cc) == -1) {
            perror("write");
            exit(1);
        }
    }
}

int myserver(int iFamily, int iProtocol, int iPort)
{
    struct sockaddr_in  laddr,    faddr;
    int                 iSock,    iNewsock, iSockopt, iProtofam;
    socklen_t           faddrlen;

/*    ASSERT(iPort);*/
    /* Set up an IPv4 TCP socket to listen on for connections. */
    laddr.sin_family      = iFamily;
    laddr.sin_port        = iPort;
    laddr.sin_addr.s_addr = INADDR_ANY;

    iProtofam             = (iFamily == AF_INET) ? PF_INET : PF_INET6;
    iSock = socket(iProtofam, SOCK_STREAM, iProtocol);

    if (iSock == -1) {
        perror("socket");
        return (-1);
    }

    /* Tell the system to allow local addresses to be reused. */
    iSockopt = 1;
    if (setsockopt(iSock, SOL_SOCKET, SO_REUSEADDR, (void *)&iSockopt,\
        sizeof (iSockopt)) == -1) {
        perror("setsockopt(SO_REUSEADDR)");
        (void) close(iSock);
        return (-1);
    }
    if (bind(iSock, (struct sockaddr *)&laddr, sizeof (laddr)) == -1) {
        perror("bind"); /* Bad bind */
        (void) close(iSock);
        return (-1);
        }
fprintf(stderr, "Listening on %d or 0x%x\n", iPort, iPort);
    if (listen(iSock, BACKLOG) == -1) {
        perror("listen"); /* Listen just blew up */
        (void) close(iSock);
        return (-1);
    }
    /* Wait for a connection request. */
    for (;;) {
        faddrlen = sizeof (faddr);
        iNewsock = accept(iSock, (struct sockaddr *)&faddr, &faddrlen);
        if (iNewsock == -1) {
            if (errno != EINTR && errno != ECONNABORTED) {
                perror("accept");
            }
            continue;
        }
        (void) printf("Connection from %s/%d\n", inet_ntoa(faddr.sin_addr), ntohs(faddr.sin_port));
        dowork(iNewsock); /* do some sockwork */
    }
    /*NOTREACHED*/
}

int main(int argc, char *argv[])
{
    char *pszArgv = NULL;
    int iFamily   = -1;
    int iNetproto = -1;
    int iNetport  = 0;

    if (argc < 2) {
        (void) fprintf(stderr, "Usage: %s [IPv6] [UDP] <Port>\n", argv[0]);
        exit(1); /* Dink donk if the user doesn't know how to use this */
    }

    if ((pszArgv = strcasedup(*argv)) == NULL)
        return -1;

    iFamily    = (strstr(pszArgv, "ipv6")) ? AF_INET6    : AF_INET;
    iNetproto  = (strstr(pszArgv, "udp"))  ? IPPROTO_UDP : IPPROTO_TCP;
    iNetport   = htons(atoi(argv[argc - 1]));

    free (pszArgv);
    return myserver(iFamily, iNetproto, iNetport);
}