/*      $NetBSD: altqd.c,v 1.11 2011/08/29 20:38:54 joerg Exp $ */
/*      $KAME: altqd.c,v 1.10 2002/02/20 10:42:26 kjc Exp $     */
/*
* Copyright (c) 2001 Theo de Raadt
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 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 AUTHOR 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.
*
* Copyright (C) 1997-2002
*      Sony Computer Science Laboratories, Inc.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS 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 SONY CSL OR 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.
*/

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <net/if.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <syslog.h>
#include <err.h>
#ifndef __FreeBSD__
#include <util.h>
#endif

#include <altq/altq.h>
#include "altq_qop.h"
#include "quip_server.h"

#ifdef __FreeBSD__
#define  ALTQD_PID_FILE         "/var/run/altqd.pid"
#endif
#define MAX_CLIENT              10

static volatile sig_atomic_t gotsig_hup, gotsig_int, gotsig_term;

__dead static void usage(void);
static void sig_handler(int);

static void
usage(void)
{
       fprintf(stderr, "usage: %s [-dv] [-f config]\n", getprogname());
       exit(1);
}

static void
sig_handler(int sig)
{
       switch (sig) {
       case SIGHUP:
               gotsig_hup = 1;
               break;
       case SIGINT:
               gotsig_int = 1;
               break;
       case SIGTERM:
               gotsig_term = 1;
               break;
       case SIGPIPE:
               /*
                * we have lost an API connection.
                * a subsequent output operation will catch EPIPE.
                */
               break;
       }
}

int
main(int argc, char **argv)
{
       int     i, c, maxfd, rval, qpsock, fd;
       fd_set  fds, rfds;
       FILE    *fp, *client[MAX_CLIENT];

       m_debug = 0;
       l_debug = LOG_INFO;
       fp = NULL;
       for (i = 0; i < MAX_CLIENT; i++)
               client[i] = NULL;

       while ((c = getopt(argc, argv, "f:vdl:")) != -1) {
               switch (c) {
               case 'f':
                       altqconfigfile = optarg;
                       break;
               case 'v':
                       l_debug = LOG_DEBUG;
                       m_debug |= DEBUG_ALTQ;
                       daemonize = 0;
                       break;
               case 'd':
                       daemonize = 0;
                       break;
               case 'l':
                       l_debug = atoi(optarg);
                       break;
               default:
                       usage();
               }
       }

       signal(SIGINT, sig_handler);
       signal(SIGTERM, sig_handler);
       signal(SIGHUP, sig_handler);
       signal(SIGPIPE, sig_handler);

       if (daemonize)
               openlog("altqd", LOG_PID, LOG_DAEMON);

       if (qcmd_init() != 0) {
               if (daemonize)
                       closelog();
               exit(1);
       }

       /*
        * open a unix domain socket for altqd clients
        */
       if ((qpsock = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0)
               LOG(LOG_ERR, errno, "can't open unix domain socket");
       else {
               struct sockaddr_un addr;

               bzero(&addr, sizeof(addr));
               addr.sun_family = AF_LOCAL;
               strlcpy(addr.sun_path, QUIP_PATH, sizeof(addr.sun_path));
               unlink(QUIP_PATH);
               if (bind(qpsock, (struct sockaddr *)&addr,
                   sizeof(addr)) < 0) {
                       LOG(LOG_ERR, errno, "can't bind to %s", QUIP_PATH);
                       close(qpsock);
                       qpsock = -1;
               }
               chmod(QUIP_PATH, 0666);
               if (listen(qpsock, SOMAXCONN) < 0) {
                       LOG(LOG_ERR, errno, "can't listen to %s", QUIP_PATH);
                       close(qpsock);
                       qpsock = -1;
               }
       }

       if (daemonize) {
               daemon(0, 0);

               /* save pid to the pid file (/var/tmp/altqd.pid) */
#ifdef __FreeBSD__
               {
                       FILE *fp;

                       if ((fp = fopen(ALTQD_PID_FILE, "w")) != NULL) {
                               fprintf(fp, "%d\n", getpid());
                               fclose(fp);
                       } else
                               LOG(LOG_WARNING, errno, "can't open pid file");
               }
#else
               pidfile(NULL);
#endif
       } else {
               /* interactive mode */
               fp = stdin;
               printf("\nEnter ? or command:\n");
               printf("altqd %s> ", cur_ifname());
               fflush(stdout);
       }

       /*
        * go into the command mode.
        */
       FD_ZERO(&fds);
       maxfd = 0;
       if (fp != NULL) {
           fd = fileno(fp);
           if (fd == -1)
                   LOG(LOG_ERR, 0, "bad file descriptor", QUIP_PATH);
       } else
               fd = -1;

       if (fd != -1) {
               FD_SET(fd, &fds);
               maxfd = MAX(maxfd, fd + 1);
       }
       if (qpsock >= 0) {
               FD_SET(qpsock, &fds);
               maxfd = MAX(maxfd, qpsock + 1);
       }

       rval = 1;
       while (rval) {
               if (gotsig_hup) {
                       qcmd_destroyall();
                       gotsig_hup = 0;
                       LOG(LOG_INFO, 0, "reinitializing altqd...");
                       if (qcmd_init() != 0) {
                               LOG(LOG_INFO, 0, "reinitialization failed");
                               break;
                       }
               }
               if (gotsig_term || gotsig_int) {
                       LOG(LOG_INFO, 0, "Exiting on signal %d",
                           gotsig_term ? SIGTERM : SIGINT);
                       break;
               }

               FD_COPY(&fds, &rfds);
               if (select(maxfd, &rfds, NULL, NULL, NULL) < 0) {
                       if (errno != EINTR)
                               err(1, "select");
                       continue;
               }

               /*
                * if there is command input, read the input line,
                * parse it, and execute.
                */
               if (fp && FD_ISSET(fd, &rfds)) {
                       rval = do_command(fp);
                       if (rval == 0) {
                               /* quit command or eof on input */
                               LOG(LOG_INFO, 0, "Exiting.");
                       } else if (fp == stdin)
                               printf("altqd %s> ", cur_ifname());
                       fflush(stdout);
               } else if (qpsock >= 0 && FD_ISSET(qpsock, &rfds)) {
                       /*
                        * quip connection request from client via unix
                        * domain socket; get a new socket for this
                        * connection and add it to the select list.
                        */
                       int newsock = accept(qpsock, NULL, NULL);

                       if (newsock == -1) {
                               LOG(LOG_ERR, errno, "accept");
                               continue;
                       }
                       FD_SET(newsock, &fds);
                       for (i = 0; i < MAX_CLIENT; i++)
                               if (client[i] == NULL) {
                                       client[i] = fdopen(newsock, "r+");
                                       break;
                               }
                       maxfd = MAX(maxfd, newsock + 1);
               } else {
                       /*
                        * check input from a client via unix domain socket
                        */
                       for (i = 0; i < MAX_CLIENT; i++) {
                               int fd1;

                               if (client[i] == NULL)
                                       continue;
                               fd1 = fileno(client[i]);
                               if (FD_ISSET(fd1, &rfds)) {
                                       if (quip_input(client[i]) != 0 ||
                                           fflush(client[i]) != 0) {
                                               /* connection closed */
                                               fclose(client[i]);
                                               client[i] = NULL;
                                               FD_CLR(fd1, &fds);
                                       }
                               }
                       }
               }
       }

       /* cleanup and exit */
       qcmd_destroyall();
       if (qpsock >= 0)
               (void)close(qpsock);
       unlink(QUIP_PATH);

       for (i = 0; i < MAX_CLIENT; i++)
               if (client[i] != NULL)
                       (void)fclose(client[i]);
       if (daemonize) {
#ifdef __FreeBSD__
               /* if we have a pid file, remove it */
               unlink(ALTQD_PID_FILE);
#endif
               closelog();
       }
       exit(0);
}