/*
 * Copyright (C) 2012 by Darren Reed.
 *
 * See the IPFILTER.LICENCE file for details on licencing.
 */
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/sockio.h>
#include <sys/errno.h>

#include <netinet/in.h>
#include <net/if.h>

#include <arpa/inet.h>

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>
#include <signal.h>

#include "ipf.h"
#include "opts.h"


#define R_IO_ERROR      -1
#define R_OKAY          0
#define R_MORE          1
#define R_SKIP          2
#if     defined(sun) && !defined(SOLARIS2)
# define        STRERROR(x)     sys_errlist[x]
extern  char    *sys_errlist[];
#else
# define        STRERROR(x)     strerror(x)
#endif


int     main(int, char *[]);
void    usage(char *);
void    printsynchdr(synchdr_t *);
void    printtable(int);
void    printsmcproto(char *);
void    printcommand(int);
int     do_kbuff(int, char *, int *);
int     do_packet(int, char *);
int     buildsocket(char *, struct sockaddr_in *);
void    do_io(void);
void    handleterm(int);

int     terminate = 0;
int     igmpfd = -1;
int     nfd = -1;
int     lfd = -1;
int     opts = 0;

void
usage(progname)
        char *progname;
{
        fprintf(stderr,
                "Usage: %s [-d] [-p port] [-i address] -I <interface>\n",
                progname);
}

void
handleterm(sig)
        int sig;
{
        terminate = sig;
}


/* should be large enough to hold header + any datatype */
#define BUFFERLEN 1400

int
main(argc, argv)
        int argc;
        char *argv[];
{
        struct sockaddr_in sin;
        char *interface;
        char *progname;
        int opt, tries;

        progname = strrchr(argv[0], '/');
        if (progname) {
                progname++;
        } else {
                progname = argv[0];
        }

        opts = 0;
        tries = 0;
        interface = NULL;

        bzero((char *)&sin, sizeof(sin));
        sin.sin_family = AF_INET;
        sin.sin_port = htons(0xaf6c);
        sin.sin_addr.s_addr = htonl(INADDR_UNSPEC_GROUP | 0x697066);

        while ((opt = getopt(argc, argv, "di:I:p:")) != -1)
                switch (opt)
                {
                case 'd' :
                        debuglevel++;
                        break;
                case 'I' :
                        interface = optarg;
                        break;
                case 'i' :
                        sin.sin_addr.s_addr = inet_addr(optarg);
                        break;
                case 'p' :
                        sin.sin_port = htons(atoi(optarg));
                        break;
                }

        if (interface == NULL) {
                usage(progname);
                exit(1);
        }

        if (!debuglevel) {

#ifdef BSD
                daemon(0, 0);
#else
                int fd = open("/dev/null", O_RDWR);

                switch (fork())
                {
                case 0 :
                        break;

                case -1 :
                        fprintf(stderr, "%s: fork() failed: %s\n",
                                argv[0], STRERROR(errno));
                        exit(1);
                        /* NOTREACHED */

                default :
                        exit(0);
                        /* NOTREACHED */
                }

                dup2(fd, 0);
                dup2(fd, 1);
                dup2(fd, 2);
                close(fd);

                setsid();
#endif
        }

        signal(SIGHUP, handleterm);
        signal(SIGINT, handleterm);
        signal(SIGTERM, handleterm);

        openlog(progname, LOG_PID, LOG_SECURITY);

        while (!terminate) {
                if (lfd != -1) {
                        close(lfd);
                        lfd = -1;
                }
                if (nfd != -1) {
                        close(nfd);
                        nfd = -1;
                }
                if (igmpfd != -1) {
                        close(igmpfd);
                        igmpfd = -1;
                }

                if (buildsocket(interface, &sin) == -1)
                        goto tryagain;

                lfd = open(IPSYNC_NAME, O_RDWR);
                if (lfd == -1) {
                        syslog(LOG_ERR, "open(%s):%m", IPSYNC_NAME);
                        debug(1, "open(%s): %s\n", IPSYNC_NAME,
                              STRERROR(errno));
                        goto tryagain;
                }

                tries = -1;
                do_io();
tryagain:
                tries++;
                syslog(LOG_INFO, "retry in %d seconds", 1 << tries);
                debug(1, "wait %d seconds\n", 1 << tries);
                sleep(1 << tries);
        }


        /* terminate */
        if (lfd != -1)
                close(lfd);
        if (nfd != -1)
                close(nfd);

        syslog(LOG_ERR, "signal %d received, exiting...", terminate);
        debug(1, "signal %d received, exiting...", terminate);

        exit(1);
}


void
do_io()
{
        char nbuff[BUFFERLEN];
        char buff[BUFFERLEN];
        fd_set mrd, rd;
        int maxfd;
        int inbuf;
        int n1;
        int left;

        FD_ZERO(&mrd);
        FD_SET(lfd, &mrd);
        FD_SET(nfd, &mrd);
        maxfd = nfd;
        if (lfd > maxfd)
                maxfd = lfd;
        debug(2, "nfd %d lfd %d maxfd %d\n", nfd, lfd, maxfd);

        inbuf = 0;
        /*
         * A threaded approach to this loop would have one thread
         * work on reading lfd (only) all the time and another thread
         * working on reading nfd all the time.
         */
        while (!terminate) {
                int n;

                rd = mrd;

                n = select(maxfd + 1, &rd, NULL, NULL, NULL);
                if (n < 0) {
                        switch (errno)
                        {
                        case EINTR :
                                continue;
                        default :
                                syslog(LOG_ERR, "select error: %m");
                                debug(1, "select error: %s\n", STRERROR(errno));
                                return;
                        }
                }

                if (FD_ISSET(lfd, &rd)) {
                        n1 = read(lfd, buff+inbuf, BUFFERLEN-inbuf);

                        debug(3, "read(K):%d\n", n1);

                        if (n1 <= 0) {
                                syslog(LOG_ERR, "read error (k-header): %m");
                                debug(1, "read error (k-header): %s\n",
                                      STRERROR(errno));
                                return;
                        }

                        left = 0;

                        switch (do_kbuff(n1, buff, &left))
                        {
                        case R_IO_ERROR :
                                return;
                        case R_MORE :
                                inbuf += left;
                                break;
                        default :
                                inbuf = 0;
                                break;
                        }
                }

                if (FD_ISSET(nfd, &rd)) {
                        n1 = recv(nfd, nbuff, sizeof(nbuff), 0);

                        debug(3, "read(N):%d\n", n1);

                        if (n1 <= 0) {
                                syslog(LOG_ERR, "read error (n-header): %m");
                                debug(1, "read error (n-header): %s\n",
                                      STRERROR(errno));
                                return;
                        }

                        switch (do_packet(n1, nbuff))
                        {
                        case R_IO_ERROR :
                                return;
                        default :
                                break;
                        }
                }
        }
}


int
buildsocket(nicname, sinp)
        char *nicname;
        struct sockaddr_in *sinp;
{
        struct sockaddr_in *reqip;
        struct ifreq req;
        char opt;

        debug(2, "binding to %s:%s\n", nicname, inet_ntoa(sinp->sin_addr));

        if (IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
                struct in_addr addr;
                struct ip_mreq mreq;

                igmpfd = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP);
                if (igmpfd == -1) {
                        syslog(LOG_ERR, "socket:%m");
                        debug(1, "socket:%s\n", STRERROR(errno));
                        return -1;
                }

                bzero((char *)&req, sizeof(req));
                strncpy(req.ifr_name, nicname, sizeof(req.ifr_name));
                req.ifr_name[sizeof(req.ifr_name) - 1] = '\0';
                if (ioctl(igmpfd, SIOCGIFADDR, &req) == -1) {
                        syslog(LOG_ERR, "ioctl(SIOCGIFADDR):%m");
                        debug(1, "ioctl(SIOCGIFADDR):%s\n", STRERROR(errno));
                        close(igmpfd);
                        igmpfd = -1;
                        return -1;
                }
                reqip = (struct sockaddr_in *)&req.ifr_addr;

                addr = reqip->sin_addr;
                if (setsockopt(igmpfd, IPPROTO_IP, IP_MULTICAST_IF,
                               (char *)&addr, sizeof(addr)) == -1) {
                        syslog(LOG_ERR, "setsockopt(IP_MULTICAST_IF(%s)):%m",
                               inet_ntoa(addr));
                        debug(1, "setsockopt(IP_MULTICAST_IF(%s)):%s\n",
                              inet_ntoa(addr), STRERROR(errno));
                        close(igmpfd);
                        igmpfd = -1;
                        return -1;
                }

                opt = 0;
                if (setsockopt(igmpfd, IPPROTO_IP, IP_MULTICAST_LOOP,
                               (char *)&opt, sizeof(opt)) == -1) {
                        syslog(LOG_ERR, "setsockopt(IP_MULTICAST_LOOP=0):%m");
                        debug(1, "setsockopt(IP_MULTICAST_LOOP=0):%s\n",
                              STRERROR(errno));
                        close(igmpfd);
                        igmpfd = -1;
                        return -1;
                }

                opt = 63;
                if (setsockopt(igmpfd, IPPROTO_IP, IP_MULTICAST_TTL,
                               (char *)&opt, sizeof(opt)) == -1) {
                        syslog(LOG_ERR, "setsockopt(IP_MULTICAST_TTL=%d):%m",
                               opt);
                        debug(1, "setsockopt(IP_MULTICAST_TTL=%d):%s\n", opt,
                              STRERROR(errno));
                        close(igmpfd);
                        igmpfd = -1;
                        return -1;
                }

                mreq.imr_multiaddr.s_addr = sinp->sin_addr.s_addr;
                mreq.imr_interface.s_addr = reqip->sin_addr.s_addr;

                if (setsockopt(igmpfd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                               (char *)&mreq, sizeof(mreq)) == -1) {
                        char buffer[80];

                        snprintf(buffer, sizeof(buffer), "%s,", inet_ntoa(sinp->sin_addr));
                        strcat(buffer, inet_ntoa(reqip->sin_addr));

                        syslog(LOG_ERR,
                               "setsockpt(IP_ADD_MEMBERSHIP,%s):%m", buffer);
                        debug(1, "setsockpt(IP_ADD_MEMBERSHIP,%s):%s\n",
                              buffer, STRERROR(errno));
                        close(igmpfd);
                        igmpfd = -1;
                        return -1;
                }
        }
        nfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (nfd == -1) {
                syslog(LOG_ERR, "socket:%m");
                if (igmpfd != -1) {
                        close(igmpfd);
                        igmpfd = -1;
                }
                return -1;
        }
        bzero((char *)&req, sizeof(req));
        strncpy(req.ifr_name, nicname, sizeof(req.ifr_name));
        req.ifr_name[sizeof(req.ifr_name) - 1] = '\0';
        if (ioctl(nfd, SIOCGIFADDR, &req) == -1) {
                syslog(LOG_ERR, "ioctl(SIOCGIFADDR):%m");
                debug(1, "ioctl(SIOCGIFADDR):%s\n", STRERROR(errno));
                close(igmpfd);
                igmpfd = -1;
                return -1;
        }

        if (bind(nfd, (struct sockaddr *)&req.ifr_addr,
                 sizeof(req.ifr_addr)) == -1) {
                syslog(LOG_ERR, "bind:%m");
                debug(1, "bind:%s\n", STRERROR(errno));
                close(nfd);
                if (igmpfd != -1) {
                        close(igmpfd);
                        igmpfd = -1;
                }
                nfd = -1;
                return -1;
        }

        if (connect(nfd, (struct sockaddr *)sinp, sizeof(*sinp)) == -1) {
                syslog(LOG_ERR, "connect:%m");
                debug(1, "connect:%s\n", STRERROR(errno));
                close(nfd);
                if (igmpfd != -1) {
                        close(igmpfd);
                        igmpfd = -1;
                }
                nfd = -1;
                return -1;
        }
        syslog(LOG_INFO, "Sending data to %s", inet_ntoa(sinp->sin_addr));
        debug(3, "Sending data to %s\n", inet_ntoa(sinp->sin_addr));

        return nfd;
}


int
do_packet(pklen, buff)
        int pklen;
        char *buff;
{
        synchdr_t *sh;
        u_32_t magic;
        int len;
        int n2;
        int n3;

        while (pklen > 0) {
                if (pklen < sizeof(*sh)) {
                        syslog(LOG_ERR, "packet length too short:%d", pklen);
                        debug(2, "packet length too short:%d\n", pklen);
                        return R_SKIP;
                }

                sh = (synchdr_t *)buff;
                len = ntohl(sh->sm_len);
                magic = ntohl(sh->sm_magic);

                if (magic != SYNHDRMAGIC) {
                        syslog(LOG_ERR, "invalid header magic %x", magic);
                        debug(2, "invalid header magic %x\n", magic);
                        return R_SKIP;
                }

                if (pklen < len + sizeof(*sh)) {
                        syslog(LOG_ERR, "packet length too short:%d", pklen);
                        debug(2, "packet length too short:%d\n", pklen);
                        return R_SKIP;
                }

                if (debuglevel > 3) {
                        printsynchdr(sh);
                        printcommand(sh->sm_cmd);
                        printtable(sh->sm_table);
                        printsmcproto(buff);
                }

                n2 = sizeof(*sh) + len;

                do {
                        n3 = write(lfd, buff, n2);
                        if (n3 <= 0) {
                                syslog(LOG_ERR, "write error: %m");
                                debug(1, "write error: %s\n", STRERROR(errno));
                                return R_IO_ERROR;
                        }

                        n2 -= n3;
                        buff += n3;
                        pklen -= n3;
                } while (n3 != 0);
        }

        return R_OKAY;
}



int
do_kbuff(inbuf, buf, left)
        int inbuf, *left;
        char *buf;
{
        synchdr_t *sh;
        u_32_t magic;
        int complete;
        int sendlen;
        int error;
        int bytes;
        int len;
        int n2;
        int n3;

        sendlen = 0;
        bytes = inbuf;
        error = R_OKAY;
        sh = (synchdr_t *)buf;

        for (complete = 0; bytes > 0; complete++) {
                len = ntohl(sh->sm_len);
                magic = ntohl(sh->sm_magic);

                if (magic != SYNHDRMAGIC) {
                        syslog(LOG_ERR,
                               "read invalid header magic 0x%x, flushing",
                               magic);
                        debug(2, "read invalid header magic 0x%x, flushing\n",
                               magic);
                        n2 = SMC_RLOG;
                        (void) ioctl(lfd, SIOCIPFFL, &n2);
                        break;
                }

                if (debuglevel > 3) {
                        printsynchdr(sh);
                        printcommand(sh->sm_cmd);
                        printtable(sh->sm_table);
                        putchar('\n');
                }

                if (bytes < sizeof(*sh) + len) {
                        debug(3, "Not enough bytes %d < %d\n", bytes,
                              sizeof(*sh) + len);
                        error = R_MORE;
                        break;
                }

                if (debuglevel > 3) {
                        printsmcproto(buf);
                }

                sendlen += len + sizeof(*sh);
                sh = (synchdr_t *)(buf + sendlen);
                bytes -= sendlen;
        }

        if (complete) {
                n3 = send(nfd, buf, sendlen, 0);
                if (n3 <= 0) {
                        syslog(LOG_ERR, "write error: %m");
                        debug(1, "write error: %s\n", STRERROR(errno));
                        return R_IO_ERROR;
                }
                debug(3, "send on %d len %d = %d\n", nfd, sendlen, n3);
                error = R_OKAY;
        }

        /* move buffer to the front,we might need to make
         * this more efficient, by using a rolling pointer
         * over the buffer and only copying it, when
         * we are reaching the end
         */
        if (bytes > 0) {
                bcopy(buf + bytes, buf, bytes);
                error = R_MORE;
        }
        debug(4, "complete %d bytes %d error %d\n", complete, bytes, error);

        *left = bytes;

        return error;
}


void
printcommand(cmd)
        int cmd;
{

        switch (cmd)
        {
        case SMC_CREATE :
                printf(" cmd:CREATE");
                break;
        case SMC_UPDATE :
                printf(" cmd:UPDATE");
                break;
        default :
                printf(" cmd:Unknown(%d)", cmd);
                break;
        }
}


void
printtable(table)
        int table;
{
        switch (table)
        {
        case SMC_NAT :
                printf(" table:NAT");
                break;
        case SMC_STATE :
                printf(" table:STATE");
                break;
        default :
                printf(" table:Unknown(%d)", table);
                break;
        }
}


void
printsmcproto(buff)
        char *buff;
{
        syncupdent_t *su;
        synchdr_t *sh;

        sh = (synchdr_t *)buff;

        if (sh->sm_cmd == SMC_CREATE) {
                ;

        } else if (sh->sm_cmd == SMC_UPDATE) {
                su = (syncupdent_t *)buff;
                if (sh->sm_p == IPPROTO_TCP) {
                        printf(" TCP Update: age %lu state %d/%d\n",
                                su->sup_tcp.stu_age,
                                su->sup_tcp.stu_state[0],
                                su->sup_tcp.stu_state[1]);
                }
        } else {
                printf("Unknown command\n");
        }
}


void
printsynchdr(sh)
        synchdr_t *sh;
{

        printf("v:%d p:%d num:%d len:%d magic:%x", sh->sm_v, sh->sm_p,
               ntohl(sh->sm_num), ntohl(sh->sm_len), ntohl(sh->sm_magic));
}