usr.sbin/rrenumd/rrenumd.c

   1 /*      $KAME: rrenumd.c,v 1.20 2000/11/08 02:40:53 itojun Exp $        */
   2
   3 /*
   4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the project nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD: src/usr.sbin/rrenumd/rrenumd.c,v 1.1.2.4 2001/07/09 09:49:49 ume Exp $
  32  * $DragonFly: src/usr.sbin/rrenumd/rrenumd.c,v 1.6 2005/12/05 02:40:28 swildner Exp $
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/socket.h>
  37 #include <sys/uio.h>
  38 #include <sys/time.h>
  39
  40 #include <string.h>
  41
  42 #include <net/route.h>
  43
  44 #include <netinet/in_systm.h>
  45 #include <netinet/in.h>
  46 #include <netinet/ip.h>
  47 #include <netinet/ip6.h>
  48 #include <netinet/icmp6.h>
  49
  50 #include <arpa/inet.h>
  51
  52 #ifdef IPSEC
  53 #include <netinet6/ipsec.h>
  54 #endif
  55
  56 #include <stdio.h>
  57 #include <err.h>
  58 #include <errno.h>
  59 #include <stdlib.h>
  60 #include <unistd.h>
  61 #include <syslog.h>
  62
  63 #include "rrenumd.h"
  64
  65 #define LL_ALLROUTERS "ff02::2"
  66 #define SL_ALLROUTERS "ff05::2"
  67
  68 #define RR_MCHLIM_DEFAULT 64
  69
  70 #ifndef IN6_IS_SCOPE_LINKLOCAL
  71 #define IN6_IS_SCOPE_LINKLOCAL(a)       \
  72         ((IN6_IS_ADDR_LINKLOCAL(a)) ||  \
  73          (IN6_IS_ADDR_MC_LINKLOCAL(a)))
  74 #endif /* IN6_IS_SCOPE_LINKLOCAL */
  75
  76 struct flags {
  77         u_long debug : 1;
  78         u_long fg : 1;
  79 #ifdef IPSEC
  80 #ifdef IPSEC_POLICY_IPSEC
  81         u_long policy : 1;
  82 #else /* IPSEC_POLICY_IPSEC */
  83         u_long auth : 1;
  84         u_long encrypt : 1;
  85 #endif /* IPSEC_POLICY_IPSEC */
  86 #endif /*IPSEC*/
  87 };
  88
  89 struct msghdr sndmhdr;
  90 struct msghdr rcvmhdr;
  91 struct sockaddr_in6 from;
  92 struct sockaddr_in6 sin6_ll_allrouters;
  93
  94 int s4, s6;
  95 int with_v4dest, with_v6dest;
  96 struct in6_addr prefix; /* ADHOC */
  97 int prefixlen = 64; /* ADHOC */
  98
  99 extern int parse(FILE **);
 100
 101 static void show_usage(void);
 102 static void init_sin6(struct sockaddr_in6 *, const char *);
 103 #if 0
 104 static void join_multi(const char *);
 105 #endif
 106 static void init_globals(void);
 107 static void config(FILE **);
 108 #ifdef IPSEC_POLICY_IPSEC
 109 static void sock6_open(struct flags *, char *);
 110 static void sock4_open(struct flags *, char *);
 111 #else
 112 static void sock6_open(struct flags *);
 113 static void sock4_open(struct flags *);
 114 #endif
 115 static void rrenum_output(struct payload_list *, struct dst_list *);
 116 static void rrenum_snd_eachdst(struct payload_list *);
 117 #if 0
 118 static void rrenum_snd_fullsequence(void);
 119 #endif
 120 static void rrenum_input(int);
 121 int main(int, char *[]);
 122
 123
 124 /* Print usage. Don't call this after daemonized. */
 125 static void
 126 show_usage(void)
 127 {
 128         fprintf(stderr, "usage: rrenumd [-c conf_file|-s] [-df"
 129 #ifdef IPSEC
 130 #ifdef IPSEC_POLICY_IPSEC
 131                 "] [-P policy"
 132 #else /* IPSEC_POLICY_IPSEC */
 133                 "AE"
 134 #endif /* IPSEC_POLICY_IPSEC */
 135 #endif /* IPSEC */
 136                 "]\n");
 137         exit(1);
 138 }
 139
 140 static void
 141 init_sin6(struct sockaddr_in6 *sin6, const char *addr_ascii)
 142 {
 143         memset(sin6, 0, sizeof(*sin6));
 144         sin6->sin6_len = sizeof(*sin6);
 145         sin6->sin6_family = AF_INET6;
 146         if (inet_pton(AF_INET6, addr_ascii, &sin6->sin6_addr) != 1)
 147                 ; /* XXX do something */
 148 }
 149
 150 #if 0  /* XXX: not necessary ?? */
 151 static void
 152 join_multi(const char *addrname)
 153 {
 154         struct ipv6_mreq mreq;
 155
 156         if (inet_pton(AF_INET6, addrname, &mreq.ipv6mr_multiaddr.s6_addr)
 157             != 1) {
 158                 syslog(LOG_ERR, "<%s> inet_pton failed(library bug?)",
 159                        __func__);
 160                 exit(1);
 161         }
 162         /* ADHOC: currently join only one */
 163         {
 164                 if ((mreq.ipv6mr_interface = if_nametoindex(ifname)) == 0) {
 165                         syslog(LOG_ERR, "<%s> ifname %s should be invalid: %s",
 166                                __func__, ifname, strerror(errno));
 167                         exit(1);
 168                 }
 169                 if (setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP,
 170                                &mreq,
 171                                sizeof(mreq)) < 0) {
 172                         syslog(LOG_ERR, "<%s> IPV6_JOIN_GROUP on %s: %s",
 173                                __func__, ifname, strerror(errno));
 174                         exit(1);
 175                 }
 176         }
 177 }
 178 #endif
 179
 180 static void
 181 init_globals(void)
 182 {
 183         static struct iovec rcviov;
 184         static u_char rprdata[4500]; /* maximal MTU of connected links */
 185         static u_char *rcvcmsgbuf = NULL;
 186         static u_char *sndcmsgbuf = NULL;
 187         int sndcmsglen, rcvcmsglen;
 188
 189         /* init ll_allrouters */
 190         init_sin6(&sin6_ll_allrouters, LL_ALLROUTERS);
 191
 192         /* initialize msghdr for receiving packets */
 193         rcviov.iov_base = (caddr_t)rprdata;
 194         rcviov.iov_len = sizeof(rprdata);
 195         rcvmhdr.msg_namelen = sizeof(struct sockaddr_in6);
 196         rcvmhdr.msg_iov = &rcviov;
 197         rcvmhdr.msg_iovlen = 1;
 198         rcvcmsglen = CMSG_SPACE(sizeof(struct in6_pktinfo)) +
 199                 CMSG_SPACE(sizeof(int));
 200         if (rcvcmsgbuf == NULL &&
 201             (rcvcmsgbuf = (u_char *)malloc(rcvcmsglen)) == NULL) {
 202                 syslog(LOG_ERR, "<%s>: malloc failed", __func__);
 203                 exit(1);
 204         }
 205         rcvmhdr.msg_control = (caddr_t)rcvcmsgbuf;
 206         rcvmhdr.msg_controllen = rcvcmsglen;
 207
 208         /* initialize msghdr for sending packets */
 209         sndmhdr.msg_namelen = sizeof(struct sockaddr_in6);
 210         sndmhdr.msg_iovlen = 1;
 211         sndcmsglen = CMSG_SPACE(sizeof(struct in6_pktinfo)) +
 212                 CMSG_SPACE(sizeof(int));
 213         if (sndcmsgbuf == NULL &&
 214             (sndcmsgbuf = (u_char *)malloc(sndcmsglen)) == NULL) {
 215                 syslog(LOG_ERR, "<%s>: malloc failed", __func__);
 216                 exit(1);
 217         }
 218         sndmhdr.msg_control = (caddr_t)sndcmsgbuf;
 219         sndmhdr.msg_controllen = sndcmsglen;
 220 }
 221
 222 static void
 223 config(FILE **fpp)
 224 {
 225         struct payload_list *pl;
 226         struct iovec *iov;
 227         struct icmp6_router_renum *irr;
 228         struct rr_pco_match *rpm;
 229
 230         if (parse(fpp) < 0) {
 231                 syslog(LOG_ERR, "<%s> parse failed", __func__);
 232                 exit(1);
 233         }
 234
 235         /* initialize fields not configured by parser */
 236         for (pl = pl_head; pl; pl = pl->pl_next) {
 237                 iov = (struct iovec *)&pl->pl_sndiov;
 238                 irr = (struct icmp6_router_renum *)&pl->pl_irr;
 239                 rpm = (struct rr_pco_match *)&pl->pl_rpm;
 240
 241                 irr->rr_type = ICMP6_ROUTER_RENUMBERING;
 242                 irr->rr_code = 0;
 243                 /*
 244                  * now we don't support multiple PCOs in a rr message.
 245                  * so segment number is not supported.
 246                  */
 247                 /* TODO: rr flags config in parser */
 248                 irr->rr_flags |= ICMP6_RR_FLAGS_SPECSITE;
 249                 /* TODO: max delay config in parser */
 250
 251                 /*
 252                  * means only 1 use_prefix is contained as router-renum-05.txt.
 253                  * now we don't support multiple PCOs in a rr message,
 254                  * nor multiple use_prefix in one PCO.
 255                  */
 256                 rpm->rpm_len = 4*1 +3;
 257                 rpm->rpm_ordinal = 0;
 258                 iov->iov_base = (caddr_t)irr;
 259                 iov->iov_len =  sizeof(struct icmp6_router_renum)
 260                         + sizeof(struct rr_pco_match)
 261                         + sizeof(struct rr_pco_use);
 262         }
 263 }
 264
 265 static void
 266 sock6_open(struct flags *flags
 267 #ifdef IPSEC_POLICY_IPSEC
 268            , char *policy
 269 #endif /* IPSEC_POLICY_IPSEC */
 270            )
 271 {
 272         struct icmp6_filter filt;
 273         int on;
 274 #ifdef IPSEC
 275 #ifndef IPSEC_POLICY_IPSEC
 276         int optval;
 277 #endif
 278 #endif
 279
 280         if (with_v6dest == 0)
 281                 return;
 282         if (with_v6dest &&
 283             (s6 = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0) {
 284                 syslog(LOG_ERR, "<%s> socket(v6): %s", __func__,
 285                        strerror(errno));
 286                 exit(1);
 287         }
 288
 289         /*
 290          * join all routers multicast addresses.
 291          */
 292 #if 0 /* XXX: not necessary ?? */
 293         join_multi(LL_ALLROUTERS);
 294         join_multi(SL_ALLROUTERS);
 295 #endif
 296
 297         /* set icmpv6 filter */
 298         ICMP6_FILTER_SETBLOCKALL(&filt);
 299         ICMP6_FILTER_SETPASS(ICMP6_ROUTER_RENUMBERING, &filt);
 300         if (setsockopt(s6, IPPROTO_ICMPV6, ICMP6_FILTER, &filt,
 301                        sizeof(filt)) < 0) {
 302                 syslog(LOG_ERR, "<%s> IICMP6_FILTER: %s",
 303                        __func__, strerror(errno));
 304                 exit(1);
 305         }
 306
 307         /* specify to tell receiving interface */
 308         on = 1;
 309         if (setsockopt(s6, IPPROTO_IPV6, IPV6_PKTINFO, &on,
 310                        sizeof(on)) < 0) {
 311                 syslog(LOG_ERR, "<%s> IPV6_PKTINFO: %s",
 312                        __func__, strerror(errno));
 313                 exit(1);
 314         }
 315
 316 #ifdef IPSEC
 317 #ifdef IPSEC_POLICY_IPSEC
 318         if (flags->policy) {
 319                 char *buf;
 320                 buf = ipsec_set_policy(policy, strlen(policy));
 321                 if (buf == NULL)
 322                         errx(1, "%s", ipsec_strerror());
 323                 /* XXX should handle in/out bound policy. */
 324                 if (setsockopt(s6, IPPROTO_IPV6, IPV6_IPSEC_POLICY,
 325                                 buf, ipsec_get_policylen(buf)) < 0)
 326                         err(1, "setsockopt(IPV6_IPSEC_POLICY)");
 327                 free(buf);
 328         }
 329 #else /* IPSEC_POLICY_IPSEC */
 330         if (flags->auth) {
 331                 optval = IPSEC_LEVEL_REQUIRE;
 332                 if (setsockopt(s6, IPPROTO_IPV6, IPV6_AUTH_TRANS_LEVEL,
 333                                &optval, sizeof(optval)) == -1) {
 334                         syslog(LOG_ERR, "<%s> IPV6_AUTH_TRANS_LEVEL: %s",
 335                                __func__, strerror(errno));
 336                         exit(1);
 337                 }
 338         }
 339         if (flags->encrypt) {
 340                 optval = IPSEC_LEVEL_REQUIRE;
 341                 if (setsockopt(s6, IPPROTO_IPV6, IPV6_ESP_TRANS_LEVEL,
 342                                 &optval, sizeof(optval)) == -1) {
 343                         syslog(LOG_ERR, "<%s> IPV6_ESP_TRANS_LEVEL: %s",
 344                                __func__, strerror(errno));
 345                         exit(1);
 346                 }
 347         }
 348 #endif /* IPSEC_POLICY_IPSEC */
 349 #endif /* IPSEC */
 350
 351         return;
 352 }
 353
 354 static void
 355 sock4_open(struct flags *flags
 356 #ifdef IPSEC_POLICY_IPSEC
 357            , char *policy
 358 #endif /* IPSEC_POLICY_IPSEC */
 359            )
 360 {
 361 #ifdef IPSEC
 362 #ifndef IPSEC_POLICY_IPSEC
 363         int optval;
 364 #endif
 365 #endif
 366
 367         if (with_v4dest == 0)
 368                 return;
 369         if ((s4 = socket(AF_INET, SOCK_RAW, IPPROTO_ICMPV6)) < 0) {
 370                 syslog(LOG_ERR, "<%s> socket(v4): %s", __func__,
 371                        strerror(errno));
 372                 exit(1);
 373         }
 374
 375 #if 0 /* XXX: not necessary ?? */
 376         /*
 377          * join all routers multicast addresses.
 378          */
 379         some_join_function();
 380 #endif
 381
 382 #ifdef IPSEC
 383 #ifdef IPSEC_POLICY_IPSEC
 384         if (flags->policy) {
 385                 char *buf;
 386                 buf = ipsec_set_policy(policy, strlen(policy));
 387                 if (buf == NULL)
 388                         errx(1, "%s", ipsec_strerror());
 389                 /* XXX should handle in/out bound policy. */
 390                 if (setsockopt(s4, IPPROTO_IP, IP_IPSEC_POLICY,
 391                                 buf, ipsec_get_policylen(buf)) < 0)
 392                         err(1, "setsockopt(IP_IPSEC_POLICY)");
 393                 free(buf);
 394         }
 395 #else /* IPSEC_POLICY_IPSEC */
 396         if (flags->auth) {
 397                 optval = IPSEC_LEVEL_REQUIRE;
 398                 if (setsockopt(s4, IPPROTO_IP, IP_AUTH_TRANS_LEVEL,
 399                                &optval, sizeof(optval)) == -1) {
 400                         syslog(LOG_ERR, "<%s> IP_AUTH_TRANS_LEVEL: %s",
 401                                __func__, strerror(errno));
 402                         exit(1);
 403                 }
 404         }
 405         if (flags->encrypt) {
 406                 optval = IPSEC_LEVEL_REQUIRE;
 407                 if (setsockopt(s4, IPPROTO_IP, IP_ESP_TRANS_LEVEL,
 408                                 &optval, sizeof(optval)) == -1) {
 409                         syslog(LOG_ERR, "<%s> IP_ESP_TRANS_LEVEL: %s",
 410                                __func__, strerror(errno));
 411                         exit(1);
 412                 }
 413         }
 414 #endif /* IPSEC_POLICY_IPSEC */
 415 #endif /* IPSEC */
 416
 417         return;
 418 }
 419
 420 static void
 421 rrenum_output(struct payload_list *pl, struct dst_list *dl)
 422 {
 423         int i, msglen = 0;
 424         struct cmsghdr *cm;
 425         struct in6_pktinfo *pi;
 426         struct sockaddr_in6 *sin6 = NULL;
 427
 428         sndmhdr.msg_name = (caddr_t)dl->dl_dst;
 429         if (dl->dl_dst->sa_family == AF_INET6)
 430                 sin6 = (struct sockaddr_in6 *)dl->dl_dst;
 431
 432         if (sin6 != NULL &&
 433             IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
 434                 int hoplimit = RR_MCHLIM_DEFAULT;
 435
 436                 cm = CMSG_FIRSTHDR(&sndmhdr);
 437                 /* specify the outgoing interface */
 438                 cm->cmsg_level = IPPROTO_IPV6;
 439                 cm->cmsg_type = IPV6_PKTINFO;
 440                 cm->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
 441                 pi = (struct in6_pktinfo *)CMSG_DATA(cm);
 442                 memset(&pi->ipi6_addr, 0, sizeof(pi->ipi6_addr));       /*XXX*/
 443                 pi->ipi6_ifindex = sin6->sin6_scope_id;
 444                 msglen += CMSG_LEN(sizeof(struct in6_pktinfo));
 445
 446                 /* specify the hop limit of the packet if dest is link local */
 447                 /* not defined by router-renum-05.txt, but maybe its OK */
 448                 cm = CMSG_NXTHDR(&sndmhdr, cm);
 449                 cm->cmsg_level = IPPROTO_IPV6;
 450                 cm->cmsg_type = IPV6_HOPLIMIT;
 451                 cm->cmsg_len = CMSG_LEN(sizeof(int));
 452                 memcpy(CMSG_DATA(cm), &hoplimit, sizeof(int));
 453                 msglen += CMSG_LEN(sizeof(int));
 454         }
 455         sndmhdr.msg_controllen = msglen;
 456         if (sndmhdr.msg_controllen == 0)
 457                 sndmhdr.msg_control = 0;
 458
 459         sndmhdr.msg_iov = &pl->pl_sndiov;
 460         i = sendmsg(dl->dl_dst->sa_family == AF_INET ? s4 : s6, &sndmhdr, 0);
 461
 462         if (i < 0 || i != sndmhdr.msg_iov->iov_len)
 463                 syslog(LOG_ERR, "<%s> sendmsg: %s", __func__,
 464                        strerror(errno));
 465 }
 466
 467 static void
 468 rrenum_snd_eachdst(struct payload_list *pl)
 469 {
 470         struct dst_list *dl;
 471
 472         for (dl = dl_head; dl; dl = dl->dl_next) {
 473                 rrenum_output(pl, dl);
 474         }
 475 }
 476
 477 #if 0
 478 static void
 479 rrenum_snd_fullsequence(void)
 480 {
 481         struct payload_list *pl;
 482
 483         for (pl = pl_head; pl; pl = pl->pl_next) {
 484                 rrenum_snd_eachdst(pl);
 485         }
 486 }
 487 #endif
 488
 489 static void
 490 rrenum_input(int s)
 491 {
 492         int i;
 493         struct icmp6_router_renum *rr;
 494
 495         /* get message */
 496         if ((i = recvmsg(s, &rcvmhdr, 0)) < 0) {
 497                 syslog(LOG_ERR, "<%s> recvmsg: %s", __func__,
 498                        strerror(errno));
 499                 return;
 500         }
 501         if (s == s4)
 502                 i -= sizeof(struct ip);
 503         if (i < sizeof(struct icmp6_router_renum)) {
 504                 syslog(LOG_ERR, "<%s> packet size(%d) is too short",
 505                        __func__, i);
 506                 return;
 507         }
 508         if (s == s4) {
 509                 struct ip *ip = (struct ip *)rcvmhdr.msg_iov->iov_base;
 510
 511                 rr = (struct icmp6_router_renum *)(ip + 1);
 512         } else /* s == s6 */
 513                 rr = (struct icmp6_router_renum *)rcvmhdr.msg_iov->iov_base;
 514
 515         switch(rr->rr_code) {
 516         case ICMP6_ROUTER_RENUMBERING_COMMAND:
 517                 /* COMMAND will be processed by rtadvd */
 518                 break;
 519         case ICMP6_ROUTER_RENUMBERING_RESULT:
 520                 /* TODO: receiving result message */
 521                 break;
 522         default:
 523                 syslog(LOG_ERR, "<%s> received unknown code %d",
 524                        __func__, rr->rr_code);
 525                 break;
 526         }
 527 }
 528
 529 int
 530 main(int argc, char *argv[])
 531 {
 532         FILE *fp = stdin;
 533         fd_set fdset;
 534         struct timeval timeout;
 535         int ch, i, maxfd = 0, send_counter = 0;
 536         struct flags flags;
 537         struct payload_list *pl;
 538 #ifdef IPSEC_POLICY_IPSEC
 539         char *policy = NULL;
 540 #endif
 541
 542         memset(&flags, 0, sizeof(flags));
 543         openlog("rrenumd", LOG_PID, LOG_DAEMON);
 544
 545         /* get options */
 546         while ((ch = getopt(argc, argv, "c:sdf"
 547 #ifdef IPSEC
 548 #ifdef IPSEC_POLICY_IPSEC
 549                             "P:"
 550 #else /* IPSEC_POLICY_IPSEC */
 551                             "AE"
 552 #endif /* IPSEC_POLICY_IPSEC */
 553 #endif /* IPSEC */
 554                             )) != -1){
 555                 switch (ch) {
 556                 case 'c':
 557                         if((fp = fopen(optarg, "r")) == NULL) {
 558                                 syslog(LOG_ERR,
 559                                        "<%s> config file %s open failed",
 560                                        __func__, optarg);
 561                                 exit(1);
 562                         }
 563                         break;
 564                 case 's':
 565                         fp = stdin;
 566                         break;
 567                 case 'd':
 568                         flags.debug = 1;
 569                         break;
 570                 case 'f':
 571                         flags.fg = 1;
 572                         break;
 573 #ifdef IPSEC
 574 #ifdef IPSEC_POLICY_IPSEC
 575                 case 'P':
 576                         flags.policy = 1;
 577                         policy = strdup(optarg);
 578                         break;
 579 #else /* IPSEC_POLICY_IPSEC */
 580                 case 'A':
 581                         flags.auth = 1;
 582                         break;
 583                 case 'E':
 584                         flags.encrypt = 1;
 585                         break;
 586 #endif /* IPSEC_POLICY_IPSEC */
 587 #endif /*IPSEC*/
 588                 default:
 589                         show_usage();
 590                 }
 591         }
 592         argc -= optind;
 593         argv += optind;
 594
 595         /* set log level */
 596         if (flags.debug == 0)
 597                 setlogmask(LOG_UPTO(LOG_ERR));
 598         if (flags.debug == 1)
 599                 setlogmask(LOG_UPTO(LOG_INFO));
 600
 601         /* init global variables */
 602         init_globals();
 603
 604         config(&fp);
 605
 606         sock6_open(&flags
 607 #ifdef IPSEC_POLICY_IPSEC
 608                    , policy
 609 #endif /* IPSEC_POLICY_IPSEC */
 610                    );
 611         sock4_open(&flags
 612 #ifdef IPSEC_POLICY_IPSEC
 613                    , policy
 614 #endif /* IPSEC_POLICY_IPSEC */
 615                    );
 616
 617         if (!flags.fg)
 618                 daemon(0, 0);
 619
 620         FD_ZERO(&fdset);
 621         if (with_v6dest) {
 622                 FD_SET(s6, &fdset);
 623                 if (s6 > maxfd)
 624                         maxfd = s6;
 625         }
 626         if (with_v4dest) {
 627                 FD_SET(s4, &fdset);
 628                 if (s4 > maxfd)
 629                         maxfd = s4;
 630         }
 631
 632         /* ADHOC: timeout each 30seconds */
 633         memset(&timeout, 0, sizeof(timeout));
 634
 635         /* init temporary payload_list and send_counter*/
 636         pl = pl_head;
 637         send_counter = retry + 1;
 638         while (1) {
 639                 struct fd_set select_fd = fdset; /* reinitialize */
 640
 641                 if ((i = select(maxfd + 1, &select_fd, NULL, NULL,
 642                                 &timeout)) < 0){
 643                         syslog(LOG_ERR, "<%s> select: %s",
 644                                __func__, strerror(errno));
 645                         continue;
 646                 }
 647                 if (i == 0) {   /* timeout */
 648                         if (pl == NULL)
 649                                 exit(0);
 650                         rrenum_snd_eachdst(pl);
 651                         send_counter--;
 652                         timeout.tv_sec = 30;
 653                         if (send_counter == 0) {
 654                                 timeout.tv_sec = 0;
 655                                 pl = pl->pl_next;
 656                                 send_counter = retry + 1;
 657                         }
 658                 }
 659                 if (FD_ISSET(s4, &select_fd))
 660                         rrenum_input(s4);
 661                 if (FD_ISSET(s6, &select_fd))
 662                         rrenum_input(s6);
 663         }
 664 }