/*      $NetBSD: faithd.c,v 1.36 2013/10/19 17:16:25 christos Exp $     */
/*      $KAME: faithd.c,v 1.62 2003/08/19 21:20:33 itojun Exp $ */

/*
* Copyright (C) 1997 and 1998 WIDE Project.
* 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.
* 3. Neither the name of the project nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 THE PROJECT 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.
*/

/*
* User level translator from IPv6 to IPv4.
*
* Usage: faithd [<port> <progpath> <arg1(progname)> <arg2> ...]
*   e.g. faithd telnet /usr/local/v6/sbin/telnetd telnetd
*/

#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/ioctl.h>

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <termios.h>

#include <net/if_types.h>
#ifdef IFT_FAITH
# define USE_ROUTE
# include <net/if.h>
# include <net/route.h>
# include <net/if_dl.h>
#endif

#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <ifaddrs.h>

#include "faithd.h"
#include "prefix.h"

char *serverpath = NULL;
char *serverarg[MAXARGV + 1];
char logname[BUFSIZ];
char procname[BUFSIZ];
struct myaddrs {
       struct myaddrs *next;
       struct sockaddr *addr;
};
struct myaddrs *myaddrs = NULL;
static const char *service;
#ifdef USE_ROUTE
static int sockfd = 0;
#endif
int dflag = 0;
static int pflag = 0;
static int inetd = 0;
static char *configfile = NULL;

static int inetd_main(int, char **);
static int daemon_main(int, char **);
static void play_service(int) __dead;
static void play_child(int, struct sockaddr *) __dead;
static int faith_prefix(struct sockaddr *);
static int map6to4(struct sockaddr_in6 *, struct sockaddr_in *);
static void sig_child(int);
static void sig_terminate(int) __dead;
static void start_daemon(void);
static void exit_stderr(const char *, ...) __printflike(1, 2) __dead;
static void grab_myaddrs(void);
static void free_myaddrs(void);
static void update_myaddrs(void);
static void usage(void) __dead;

int
main(int argc, char **argv)
{

       /*
        * Initializing stuff
        */

       setprogname(argv[0]);

       if (strcmp(getprogname(), "faithd") != 0) {
               inetd = 1;
               return inetd_main(argc, argv);
       } else
               return daemon_main(argc, argv);
}

static int
inetd_main(int argc, char **argv)
{
       char path[MAXPATHLEN];
       struct sockaddr_storage me;
       struct sockaddr_storage from;
       socklen_t melen, fromlen;
       int i;
       int error;
       const int on = 1;
       char sbuf[NI_MAXSERV], snum[NI_MAXSERV];

       if (config_load(configfile) < 0 && configfile) {
               exit_failure("could not load config file");
               /*NOTREACHED*/
       }

       if (strrchr(argv[0], '/') == NULL)
               (void)snprintf(path, sizeof(path), "%s/%s", DEFAULT_DIR,
                   argv[0]);
       else
               (void)snprintf(path, sizeof(path), "%s", argv[0]);

#ifdef USE_ROUTE
       grab_myaddrs();

       sockfd = socket(PF_ROUTE, SOCK_RAW, PF_UNSPEC);
       if (sockfd < 0) {
               exit_failure("socket(PF_ROUTE): %s", strerror(errno));
               /*NOTREACHED*/
       }
#endif

       melen = sizeof(me);
       if (getsockname(STDIN_FILENO, (void *)&me, &melen) == -1) {
               exit_failure("getsockname: %s", strerror(errno));
               /*NOTREACHED*/
       }
       fromlen = sizeof(from);
       if (getpeername(STDIN_FILENO, (void *)&from, &fromlen) == -1) {
               exit_failure("getpeername: %s", strerror(errno));
               /*NOTREACHED*/
       }
       if (getnameinfo((void *)&me, melen, NULL, 0,
           sbuf, (socklen_t)sizeof(sbuf), NI_NUMERICHOST) == 0)
               service = sbuf;
       else
               service = DEFAULT_PORT_NAME;
       if (getnameinfo((void *)&me, melen, NULL, 0,
           snum, (socklen_t)sizeof(snum), NI_NUMERICHOST) != 0)
               (void)snprintf(snum, sizeof(snum), "?");

       (void)snprintf(logname, sizeof(logname), "faithd %s", snum);
       (void)snprintf(procname, sizeof(procname), "accepting port %s", snum);
       openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);

       if (argc >= MAXARGV) {
               exit_failure("too many arguments");
               /*NOTREACHED*/
       }
       serverarg[0] = serverpath = path;
       for (i = 1; i < argc; i++)
               serverarg[i] = argv[i];
       serverarg[i] = NULL;

       error = setsockopt(STDIN_FILENO, SOL_SOCKET, SO_OOBINLINE, &on,
           (socklen_t)sizeof(on));
       if (error < 0) {
               exit_failure("setsockopt(SO_OOBINLINE): %s", strerror(errno));
               /*NOTREACHED*/
       }

       play_child(STDIN_FILENO, (void *)&from);
       exit_failure("should not reach here");
       return 0;       /*dummy!*/
}

static int
daemon_main(int argc, char **argv)
{
       struct addrinfo hints, *res;
       int s_wld, error, i, serverargc, on = 1;
       int family = AF_INET6;
       int c;

       while ((c = getopt(argc, argv, "df:p")) != -1) {
               switch (c) {
               case 'd':
                       dflag++;
                       break;
               case 'f':
                       configfile = optarg;
                       break;
               case 'p':
                       pflag++;
                       break;
               default:
                       usage();
                       /*NOTREACHED*/
               }
       }
       argc -= optind;
       argv += optind;

       if (config_load(configfile) < 0 && configfile) {
               exit_failure("could not load config file");
               /*NOTREACHED*/
       }


#ifdef USE_ROUTE
       grab_myaddrs();
#endif

       switch (argc) {
       case 0:
               usage();
               /*NOTREACHED*/
       default:
               serverargc = argc - NUMARG;
               if (serverargc >= MAXARGV)
                       exit_stderr("too many arguments");

               serverpath = strdup(argv[NUMPRG]);
               if (!serverpath)
                       exit_stderr("not enough core");
               for (i = 0; i < serverargc; i++) {
                       serverarg[i] = strdup(argv[i + NUMARG]);
                       if (!serverarg[i])
                               exit_stderr("not enough core");
               }
               serverarg[i] = NULL;
               /*FALLTHROUGH*/
       case 1: /* no local service */
               service = argv[NUMPRT];
               break;
       }

       start_daemon();

       /*
        * Opening wild card socket for this service.
        */

       memset(&hints, 0, sizeof(hints));
       hints.ai_flags = AI_PASSIVE;
       hints.ai_family = family;
       hints.ai_socktype = SOCK_STREAM;
       hints.ai_protocol = IPPROTO_TCP;        /* SCTP? */
       error = getaddrinfo(NULL, service, &hints, &res);
       if (error)
               exit_failure("getaddrinfo: %s", gai_strerror(error));

       s_wld = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
       if (s_wld == -1)
               exit_failure("socket: %s", strerror(errno));

#ifdef IPV6_FAITH
       if (res->ai_family == AF_INET6) {
               error = setsockopt(s_wld, IPPROTO_IPV6, IPV6_FAITH, &on,
                   (socklen_t)sizeof(on));
               if (error == -1)
                       exit_failure("setsockopt(IPV6_FAITH): %s",
                           strerror(errno));
       }
#endif

       error = setsockopt(s_wld, SOL_SOCKET, SO_REUSEADDR, &on,
           (socklen_t)sizeof(on));
       if (error == -1)
               exit_failure("setsockopt(SO_REUSEADDR): %s", strerror(errno));

       error = setsockopt(s_wld, SOL_SOCKET, SO_OOBINLINE, &on,
           (socklen_t)sizeof(on));
       if (error == -1)
               exit_failure("setsockopt(SO_OOBINLINE): %s", strerror(errno));

#ifdef IPV6_V6ONLY
       error = setsockopt(s_wld, IPPROTO_IPV6, IPV6_V6ONLY, &on,
           (socklen_t)sizeof(on));
       if (error == -1)
               exit_failure("setsockopt(IPV6_V6ONLY): %s", strerror(errno));
#endif

       error = bind(s_wld, (struct sockaddr *)res->ai_addr, res->ai_addrlen);
       if (error == -1)
               exit_failure("bind: %s", strerror(errno));

       error = listen(s_wld, 5);
       if (error == -1)
               exit_failure("listen: %s", strerror(errno));

#ifdef USE_ROUTE
       sockfd = socket(PF_ROUTE, SOCK_RAW, PF_UNSPEC);
       if (sockfd < 0) {
               exit_failure("socket(PF_ROUTE): %s", strerror(errno));
               /*NOTREACHED*/
       }
#endif

       /*
        * Everything is OK.
        */

       (void)snprintf(logname, sizeof(logname), "faithd %s", service);
       (void)snprintf(procname, sizeof(procname), "accepting port %s", service);
       openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
       syslog(LOG_INFO, "Staring faith daemon for %s port", service);

       play_service(s_wld);
       return 1;
}

static void
play_service(int s_wld)
{
       struct sockaddr_storage srcaddr;
       socklen_t len;
       int s_src;
       pid_t child_pid;
       struct pollfd pfd[2];
       int error;

       /*
        * Wait, accept, fork, faith....
        */
again:
       setproctitle("%s", procname);

       pfd[0].fd = s_wld;
       pfd[0].events = POLLIN;
       pfd[1].fd = -1;
       pfd[1].revents = 0;
#ifdef USE_ROUTE
       if (sockfd) {
               pfd[1].fd = sockfd;
               pfd[1].events = POLLIN;
       }
#endif

       error = poll(pfd, (unsigned int)(sizeof(pfd) / sizeof(pfd[0])), INFTIM);
       if (error < 0) {
               if (errno == EINTR)
                       goto again;
               exit_failure("select: %s", strerror(errno));
               /*NOTREACHED*/
       }

#ifdef USE_ROUTE
       if (pfd[1].revents & POLLIN)
       {
               update_myaddrs();
       }
#endif
       if (pfd[0].revents & POLLIN)
       {
               len = sizeof(srcaddr);
               s_src = accept(s_wld, (void *)&srcaddr, &len);
               if (s_src < 0) {
                       if (errno == ECONNABORTED)
                               goto again;
                       exit_failure("socket: %s", strerror(errno));
                       /*NOTREACHED*/
               }
               if (srcaddr.ss_family == AF_INET6 &&
                   IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)(void *)&srcaddr)->sin6_addr)) {
                       (void)close(s_src);
                       syslog(LOG_ERR, "connection from IPv4 mapped address?");
                       goto again;
               }

               child_pid = fork();

               if (child_pid == 0) {
                       /* child process */
                       (void)close(s_wld);
                       closelog();
                       openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
                       play_child(s_src, (void *)&srcaddr);
                       exit_failure("should never reach here");
                       /*NOTREACHED*/
               } else {
                       /* parent process */
                       (void)close(s_src);
                       if (child_pid == -1)
                               syslog(LOG_ERR, "can't fork");
               }
       }
       goto again;
}

static void
play_child(int s_src, struct sockaddr *srcaddr)
{
       struct sockaddr_storage dstaddr6;
       struct sockaddr_storage dstaddr4;
       char src[NI_MAXHOST];
       char dst6[NI_MAXHOST];
       char dst4[NI_MAXHOST];
       socklen_t len = sizeof(dstaddr6);
       int s_dst, error, hport, nresvport, on = 1;
       struct timeval tv;
       struct sockaddr *sa4;
       const struct config *conf;

       tv.tv_sec = 1;
       tv.tv_usec = 0;

       (void)getnameinfo(srcaddr, (socklen_t)srcaddr->sa_len,
           src, (socklen_t)sizeof(src), NULL, 0, NI_NUMERICHOST);
       syslog(LOG_INFO, "accepted a client from %s", src);

       error = getsockname(s_src, (void *)&dstaddr6, &len);
       if (error == -1) {
               exit_failure("getsockname: %s", strerror(errno));
               /*NOTREACHED*/
       }

       (void)getnameinfo((void *)&dstaddr6, len,
           dst6, (socklen_t)sizeof(dst6), NULL, 0, NI_NUMERICHOST);
       syslog(LOG_INFO, "the client is connecting to %s", dst6);

       if (!faith_prefix((void *)&dstaddr6)) {
               if (serverpath) {
                       /*
                        * Local service
                        */
                       syslog(LOG_INFO, "executing local %s", serverpath);
                       if (!inetd) {
                               (void)dup2(s_src, 0);
                               (void)close(s_src);
                               (void)dup2(0, 1);
                               (void)dup2(0, 2);
                       }
                       (void)execv(serverpath, serverarg);
                       syslog(LOG_ERR, "execv %s: %s", serverpath,
                           strerror(errno));
                       _exit(EXIT_FAILURE);
               } else {
                       (void)close(s_src);
                       exit_success("no local service for %s", service);
               }
       }

       /*
        * Act as a translator
        */

       switch (((struct sockaddr *)(void *)&dstaddr6)->sa_family) {
       case AF_INET6:
               if (!map6to4((struct sockaddr_in6 *)(void *)&dstaddr6,
                   (struct sockaddr_in *)(void *)&dstaddr4)) {
                       (void)close(s_src);
                       exit_failure("map6to4 failed");
                       /*NOTREACHED*/
               }
               syslog(LOG_INFO, "translating from v6 to v4");
               break;
       default:
               (void)close(s_src);
               exit_failure("family not supported");
               /*NOTREACHED*/
       }

       sa4 = (void *)&dstaddr4;
       (void)getnameinfo(sa4, (socklen_t)sa4->sa_len,
           dst4, (socklen_t)sizeof(dst4), NULL, 0, NI_NUMERICHOST);

       conf = config_match(srcaddr, sa4);
       if (!conf || !conf->permit) {
               (void)close(s_src);
               if (conf) {
                       exit_failure("translation to %s not permitted for %s",
                           dst4, prefix_string(&conf->match));
                       /*NOTREACHED*/
               } else {
                       exit_failure("translation to %s not permitted", dst4);
                       /*NOTREACHED*/
               }
       }

       syslog(LOG_INFO, "the translator is connecting to %s", dst4);

       setproctitle("port %s, %s -> %s", service, src, dst4);

       if (sa4->sa_family == AF_INET6)
               hport = ntohs(((struct sockaddr_in6 *)(void *)&dstaddr4)->sin6_port);
       else /* AF_INET */
               hport = ntohs(((struct sockaddr_in *)(void *)&dstaddr4)->sin_port);

       if (pflag)
               s_dst = rresvport_af(&nresvport, sa4->sa_family);
       else
               s_dst = socket(sa4->sa_family, SOCK_STREAM, 0);
       if (s_dst < 0) {
               exit_failure("socket: %s", strerror(errno));
               /*NOTREACHED*/
       }

       if (conf->src.a.ss_family) {
               if (bind(s_dst, (const void*)&conf->src.a,
                   (socklen_t)conf->src.a.ss_len) < 0) {
                       exit_failure("bind: %s", strerror(errno));
                       /*NOTREACHED*/
               }
       }

       error = setsockopt(s_dst, SOL_SOCKET, SO_OOBINLINE, &on,
           (socklen_t)sizeof(on));
       if (error < 0) {
               exit_failure("setsockopt(SO_OOBINLINE): %s", strerror(errno));
               /*NOTREACHED*/
       }

       error = setsockopt(s_src, SOL_SOCKET, SO_SNDTIMEO, &tv,
           (socklen_t)sizeof(tv));
       if (error < 0) {
               exit_failure("setsockopt(SO_SNDTIMEO): %s", strerror(errno));
               /*NOTREACHED*/
       }
       error = setsockopt(s_dst, SOL_SOCKET, SO_SNDTIMEO, &tv,
           (socklen_t)sizeof(tv));
       if (error < 0) {
               exit_failure("setsockopt(SO_SNDTIMEO): %s", strerror(errno));
               /*NOTREACHED*/
       }

       error = connect(s_dst, sa4, (socklen_t)sa4->sa_len);
       if (error < 0) {
               exit_failure("connect: %s", strerror(errno));
               /*NOTREACHED*/
       }

       switch (hport) {
       case FTP_PORT:
               ftp_relay(s_src, s_dst);
               break;
       default:
               tcp_relay(s_src, s_dst, service);
               break;
       }

       /* NOTREACHED */
}

/* 0: non faith, 1: faith */
static int
faith_prefix(struct sockaddr *dst)
{
#ifndef USE_ROUTE
       int mib[4], size;
       struct in6_addr faith_prefix;
       struct sockaddr_in6 *dst6 = (struct sockaddr_in *)dst;

       if (dst->sa_family != AF_INET6)
               return 0;

       mib[0] = CTL_NET;
       mib[1] = PF_INET6;
       mib[2] = IPPROTO_IPV6;
       mib[3] = IPV6CTL_FAITH_PREFIX;
       size = sizeof(struct in6_addr);
       if (sysctl(mib, 4, &faith_prefix, &size, NULL, 0) < 0) {
               exit_failure("sysctl: %s", strerror(errno));
               /*NOTREACHED*/
       }

       return memcmp(dst, &faith_prefix,
           sizeof(struct in6_addr) - sizeof(struct in_addr)) == 0;
#else
       struct myaddrs *p;
       struct sockaddr_in6 *sin6;
       struct sockaddr_in *sin4;
       struct sockaddr_in6 *dst6;
       struct sockaddr_in *dst4;
       struct sockaddr_in dstmap;

       dst6 = (void *)dst;
       if (dst->sa_family == AF_INET6
        && IN6_IS_ADDR_V4MAPPED(&dst6->sin6_addr)) {
               /* ugly... */
               memset(&dstmap, 0, sizeof(dstmap));
               dstmap.sin_family = AF_INET;
               dstmap.sin_len = sizeof(dstmap);
               memcpy(&dstmap.sin_addr, &dst6->sin6_addr.s6_addr[12],
                       sizeof(dstmap.sin_addr));
               dst = (void *)&dstmap;
       }

       dst6 = (void *)dst;
       dst4 = (void *)dst;

       for (p = myaddrs; p; p = p->next) {
               sin6 = (void *)p->addr;
               sin4 = (void *)p->addr;

               if (p->addr->sa_len != dst->sa_len
                || p->addr->sa_family != dst->sa_family)
                       continue;

               switch (dst->sa_family) {
               case AF_INET6:
                       if (sin6->sin6_scope_id == dst6->sin6_scope_id
                        && IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, &dst6->sin6_addr))
                               return 0;
                       break;
               case AF_INET:
                       if (sin4->sin_addr.s_addr == dst4->sin_addr.s_addr)
                               return 0;
                       break;
               }
       }
       return 1;
#endif
}

/* 0: non faith, 1: faith */
static int
map6to4(struct sockaddr_in6 *dst6, struct sockaddr_in *dst4)
{
       memset(dst4, 0, sizeof(*dst4));
       dst4->sin_len = sizeof(*dst4);
       dst4->sin_family = AF_INET;
       dst4->sin_port = dst6->sin6_port;
       memcpy(&dst4->sin_addr, &dst6->sin6_addr.s6_addr[12],
               sizeof(dst4->sin_addr));

       if (dst4->sin_addr.s_addr == INADDR_ANY
        || dst4->sin_addr.s_addr == INADDR_BROADCAST
        || IN_MULTICAST(ntohl(dst4->sin_addr.s_addr)))
               return 0;

       return 1;
}


static void
/*ARGSUSED*/
sig_child(int sig)
{
       int status;
       pid_t pid;

       while ((pid = wait3(&status, WNOHANG, (struct rusage *)0)) > 0)
               if (WEXITSTATUS(status))
                       syslog(LOG_WARNING, "child %ld exit status 0x%x",
                           (long)pid, status);
}

static void
/*ARGSUSED*/
sig_terminate(int sig)
{
       syslog(LOG_INFO, "Terminating faith daemon");
       exit(EXIT_SUCCESS);
}

static void
start_daemon(void)
{
#ifdef SA_NOCLDWAIT
       struct sigaction sa;
#endif

       if (daemon(0, 0) == -1)
               exit_stderr("daemon: %s", strerror(errno));

#ifdef SA_NOCLDWAIT
       (void)memset(&sa, 0, sizeof(sa));
       sa.sa_handler = sig_child;
       sa.sa_flags = SA_NOCLDWAIT;
       (void)sigemptyset(&sa.sa_mask);
       (void)sigaction(SIGCHLD, &sa, (struct sigaction *)0);
#else
       if (signal(SIGCHLD, sig_child) == SIG_ERR) {
               exit_failure("signal CHLD: %s", strerror(errno));
               /*NOTREACHED*/
       }
#endif

       if (signal(SIGTERM, sig_terminate) == SIG_ERR) {
               exit_failure("signal TERM: %s", strerror(errno));
               /*NOTREACHED*/
       }
}

static void
exit_stderr(const char *fmt, ...)
{
       va_list ap;

       va_start(ap, fmt);
       (void)fprintf(stderr, "%s: ", getprogname());
       (void)vfprintf(stderr, fmt, ap);
       va_end(ap);
       exit(EXIT_FAILURE);
}

void
exit_failure(const char *fmt, ...)
{
       va_list ap;

       va_start(ap, fmt);
       vsyslog(LOG_ERR, fmt, ap);
       va_end(ap);
       exit(EXIT_FAILURE);
}

void
exit_success(const char *fmt, ...)
{
       va_list ap;

       va_start(ap, fmt);
       vsyslog(LOG_INFO, fmt, ap);
       va_end(ap);
       exit(EXIT_SUCCESS);
}

#ifdef USE_ROUTE
static void
grab_myaddrs(void)
{
       struct ifaddrs *ifap, *ifa;
       struct myaddrs *p;

       if (getifaddrs(&ifap) != 0) {
               exit_failure("getifaddrs");
               /*NOTREACHED*/
       }

       for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
               switch (ifa->ifa_addr->sa_family) {
               case AF_INET:
               case AF_INET6:
                       break;
               default:
                       continue;
               }

               p = (struct myaddrs *)malloc(sizeof(struct myaddrs) +
                   ifa->ifa_addr->sa_len);
               if (!p) {
                       exit_failure("not enough core");
                       /*NOTREACHED*/
               }
               memcpy(p + 1, ifa->ifa_addr, ifa->ifa_addr->sa_len);
               p->next = myaddrs;
               p->addr = (void *)(p + 1);
               if (ifa->ifa_addr->sa_family == AF_INET6) {
                       struct sockaddr_in6 *sin6 = (void *)p->addr;
                       inet6_getscopeid(sin6, INET6_IS_ADDR_LINKLOCAL|
                               INET6_IS_ADDR_SITELOCAL);
               }
               myaddrs = p;
               if (dflag) {
                       char hbuf[NI_MAXHOST];
                       (void)getnameinfo(p->addr, (socklen_t)p->addr->sa_len,
                           hbuf, (socklen_t)sizeof(hbuf), NULL, 0,
                           NI_NUMERICHOST);
                       syslog(LOG_INFO, "my interface: %s %s", hbuf,
                           ifa->ifa_name);
               }
       }

       freeifaddrs(ifap);
}

static void
free_myaddrs(void)
{
       struct myaddrs *p, *q;

       p = myaddrs;
       while (p) {
               q = p->next;
               free(p);
               p = q;
       }
       myaddrs = NULL;
}

static void
update_myaddrs(void)
{
       char msg[BUFSIZ];
       ssize_t len;
       struct rt_msghdr *rtm;

       len = read(sockfd, msg, sizeof(msg));
       if (len < 0) {
               syslog(LOG_ERR, "read(PF_ROUTE) failed");
               return;
       }
       rtm = (void *)msg;
       if (len < 4 || len < rtm->rtm_msglen) {
               syslog(LOG_ERR, "read(PF_ROUTE) short read");
               return;
       }
       if (rtm->rtm_version != RTM_VERSION) {
               syslog(LOG_ERR, "routing socket version mismatch");
               (void)close(sockfd);
               sockfd = 0;
               return;
       }
       switch (rtm->rtm_type) {
       case RTM_NEWADDR:
       case RTM_DELADDR:
       case RTM_IFINFO:
               break;
       default:
               return;
       }
       /* XXX more filters here? */

       syslog(LOG_INFO, "update interface address list");
       free_myaddrs();
       grab_myaddrs();
}
#endif /*USE_ROUTE*/

static void
usage(void)
{
       (void)fprintf(stderr,
           "Usage: %s [-dp] [-f conf] service [serverpath [serverargs]]\n",
           getprogname());
       exit(0);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.