chiark / gitweb /
Implement `keepalive' site option, to try to keep link always up.
[secnet] / polypath.c
1 /* polypath
2  * send/receive module for secnet
3  * for multi-route setups */
4 /*
5  * This file is part of secnet.
6  * See README for full list of copyright holders.
7  *
8  * secnet is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version d of the License, or
11  * (at your option) any later version.
12  * 
13  * secnet is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  * 
18  * You should have received a copy of the GNU General Public License
19  * version 3 along with secnet; if not, see
20  * https://www.gnu.org/licenses/gpl.html.
21  */
22
23 #include "secnet.h"
24 #include "util.h"
25 #include "unaligned.h"
26 #include "comm-common.h"
27
28 #include <adns.h>
29 #include <ctype.h>
30
31 #ifdef CONFIG_IPV6
32
33 static comm_sendmsg_fn polypath_sendmsg;
34
35 struct interf {
36     char *name; /* from malloc */
37     struct udpsocks socks;
38     bool_t experienced_xmit_noaf[MAX_AF+1];
39     LIST_ENTRY(interf) entry;
40 };
41
42 struct polypath {
43     struct udpcommon uc;
44     int max_interfs;
45     const char *const *ifname_pats;
46     const char *const *monitor_command;
47     bool_t permit_loopback;
48     LIST_HEAD(,interf) interfs;
49     struct buffer_if lbuf;
50     int monitor_fd;
51     pid_t monitor_pid;
52     int privsep_incoming_fd;
53     int privsep_ipcsock_fd;
54 };
55
56 static void polypath_phase_shutdown(void *sst, uint32_t newphase);
57
58 #define LG 0, st->uc.cc.cl.description, &st->uc.cc.loc
59
60 static const char *const default_loopback_ifname_pats[] = {
61     "!lo", 0
62 };
63 static const char *const default_ifname_pats[] = {
64     "!tun*","!tap*","!sl*","!userv*", "*", 0
65 };
66
67 static const char *const default_monitor_command[] = {
68 #if __linux__
69     DATAROOTDIR "/secnet/" "polypath-interface-monitor-linux", 0
70 #else
71     0
72 #endif
73 };
74
75 static const char *polypath_addr_to_string(void *commst,
76                                            const struct comm_addr *ca)
77 {
78     static char sbuf[100];
79
80     snprintf(sbuf, sizeof(sbuf), "polypath:%s",
81              iaddr_to_string(&ca->ia));
82     return sbuf;
83 }
84
85 static bool_t ifname_search_pats(struct polypath *st, struct cloc loc,
86                                  const char *ifname, bool_t *want_io,
87                                  const char *const *pats) {
88     /* Returns True iff we found a list entry, in which case *want_io
89      * is set to the sense of that entry.  Otherwise *want_io is set
90      * to the sense of the last entry, or unchanged if there were no pats. */
91     if (!pats)
92         return False;
93     const char *const *pati;
94     for (pati=pats; *pati; pati++) {
95         const char *pat=*pati;
96         if (*pat=='!') { *want_io=False; pat++; }
97         else if (*pat=='+') { *want_io=True; pat++; }
98         else if (*pat=='*' || isalnum((unsigned char)*pat)) { *want_io=True; }
99         else cfgfatal(loc,"polypath","invalid interface name pattern `%s'",pat);
100         int match=fnmatch(pat,ifname,0);
101         if (match==0) return True;
102         if (match!=FNM_NOMATCH)
103             cfgfatal(loc,"polypath","fnmatch failed! (pattern `%s')",pat);
104     }
105     return False;
106 }
107
108 static bool_t ifname_wanted(struct polypath *st, struct cloc loc,
109                             const char *ifname) {
110     bool_t want=False; /* pretend an empty cfg ends with !<doesn'tmatch> */
111     if (ifname_search_pats(st,loc,ifname,&want, st->ifname_pats))
112         return want;
113     if (want) /* last pattern was positive, do not search default */
114         return False;
115     if (!st->permit_loopback &&
116         ifname_search_pats(st,loc,ifname,&want, default_loopback_ifname_pats))
117         return want;
118     if (ifname_search_pats(st,loc,ifname,&want, default_ifname_pats))
119         return want;
120     abort();
121 }
122
123 static int polypath_beforepoll(void *state, struct pollfd *fds, int *nfds_io,
124                                int *timeout_io)
125 {
126     struct polypath *st=state;
127     BEFOREPOLL_WANT_FDS(1);
128     fds[0].fd=st->monitor_fd;
129     fds[0].events=POLLIN;
130     return 0;
131 }
132
133 static inline bool_t matches32(uint32_t word, uint32_t prefix, int prefixlen)
134 {
135     assert(prefixlen>0);
136     assert(prefixlen<=32);
137     uint32_t mask = ~(((uint32_t)1 << (32-prefixlen)) - 1);
138     assert(!(prefix & ~mask));
139     return (word & mask) == prefix;
140 }
141
142 /* These macros expect
143  *    bad_fn_type *const bad;
144  *    void *badctx;
145  * and
146  *   out:
147  */
148 #define BAD(m)     do{ bad(st,badctx,M_WARNING,m,0);  goto out; }while(0)
149 #define BADE(m,ev) do{ bad(st,badctx,M_WARNING,m,ev); goto out; }while(0)
150 typedef void bad_fn_type(struct polypath *st, void *badctx,
151                          int mclass, const char* m, int ev);
152
153 typedef void polypath_ppml_callback_type(struct polypath *st,
154           bad_fn_type *bad, void *badctx,
155           bool_t add, const char *ifname, const char *ifaddr,
156           const union iaddr *ia, int fd /* -1 if none yet */);
157
158 struct ppml_bad_ctx {
159     const char *orgl;
160     char *undospace;
161 };
162
163 static void ppml_bad(struct polypath *st, void *badctx,
164                      int mclass, const char *m, int ev)
165 {
166     struct ppml_bad_ctx *bc=badctx;
167     if (bc->undospace)
168         *(bc->undospace)=' ';
169     lg_perror(LG,mclass,ev,
170               "error processing polypath state change: %s"
171               " (while processing `%s')",
172               m,bc->orgl);
173 }
174
175 static void polypath_process_monitor_line(struct polypath *st, char *orgl,
176                                       polypath_ppml_callback_type *callback)
177     /* always calls callback with fd==-1 */
178 {
179     struct udpcommon *uc=&st->uc;
180     char *l=orgl;
181     bad_fn_type (*const bad)=ppml_bad;
182     struct ppml_bad_ctx badctx[1]={{
183             .orgl=orgl,
184             .undospace=0
185         }};
186
187     bool_t add;
188     int c=*l++;
189     if (c=='+') add=True;
190     else if (c=='-') add=False;
191     else BAD("bad +/-");
192
193     int proto;
194     c=*l++;
195     if (c=='4') proto=AF_INET;
196     else if (c=='6') proto=AF_INET6;
197     else BAD("bad proto");
198
199     char *space=strchr(l,' ');
200     if (!space) BAD("no first space");
201     const char *ifname=space+1;
202
203     space=strchr(ifname,' ');
204     if (!space) BAD("no second space");
205     const char *ifaddr=space+1;
206     *space=0;
207     badctx->undospace=space;
208
209     union iaddr ia;
210     FILLZERO(ia);
211     socklen_t salen=sizeof(ia);
212     int r=adns_text2addr(ifaddr,uc->port, adns_qf_addrlit_ipv4_quadonly,
213                          &ia.sa, &salen);
214     assert(r!=ENOSPC);
215     if (r) BADE("adns_text2addr",r);
216     if (ia.sa.sa_family!=proto) BAD("address family mismatch");
217
218 #define DONT(m) do{                                                     \
219         if (add)                                                        \
220             lg_perror(LG,M_INFO,0,"ignoring %s [%s]: %s",ifname,ifaddr,m); \
221         goto out;                                                       \
222     }while(0)
223
224     if (!ifname_wanted(st,st->uc.cc.loc,ifname))
225         DONT("unwanted interface name");
226
227     switch (ia.sa.sa_family) {
228     case AF_INET6: {
229         const struct in6_addr *i6=&ia.sin6.sin6_addr;
230 #define DONTKIND(X,m) \
231         if (IN6_IS_ADDR_##X(i6)) DONT("IPv6 address is " m)
232         DONTKIND(UNSPECIFIED, "unspecified");
233         DONTKIND(MULTICAST  , "multicast"  );
234         DONTKIND(LINKLOCAL  , "link local" );
235         DONTKIND(SITELOCAL  , "site local" );
236         DONTKIND(V4MAPPED   , "v4-mapped"  );
237         if (!st->permit_loopback)
238             DONTKIND(LOOPBACK   , "loopback"   );
239 #undef DONTKIND
240 #define DONTMASK(w7x,w6x,prefixlen,m)                                   \
241         if (matches32(get_uint32(i6->s6_addr),                          \
242                       ((uint32_t)0x##w7x << 16) | (uint32_t)0x##w6x,    \
243                       prefixlen))                                       \
244             DONT("IPv6 address is " m)
245         DONTMASK( 100,   0,  8, "Discard-Only (RFC6666)");
246         DONTMASK(2001,   0, 23, "in IETF protocol block (RFC2928)");
247         DONTMASK(fc00,   0,  7, "Uniqe Local unicast (RFC4193)");
248 #undef DONTMASK
249         break;
250     }
251     case AF_INET: {
252         const uint32_t i4=htonl(ia.sin.sin_addr.s_addr);
253         if (i4==INADDR_ANY) DONT("IPv4 address is any/unspecified");
254         if (i4==INADDR_BROADCAST) DONT("IPv4 address is all hosts broadcast");
255 #define DONTMASK(b3,b2,b1,b0,prefixlen,m) do{                           \
256             const uint8_t prefixbytes[4] = { (b3),(b2),(b1),(b0) };     \
257             if (matches32(i4,get_uint32(prefixbytes),prefixlen))        \
258                 DONT("IPv4 address is " m);                             \
259         }while(0)
260         DONTMASK(169,254,0,0, 16, "link local");
261         DONTMASK(224,  0,0,0,  4, "multicast");
262         DONTMASK(192,  0,0,0, 24, "in IETF protocol block (RFC6890)");
263         DONTMASK(240,  0,0,0,  4, "in reserved addressing block (RFC1112)");
264         if (!st->permit_loopback)
265             DONTMASK(127,  0,0,0,  8, "loopback");
266 #undef DONTMASK
267         break;
268     }
269     default:
270         abort();
271     }
272
273 #undef DONT
274
275     /* OK, process it */
276     callback(st, bad,badctx, add,ifname,ifaddr,&ia,-1);
277
278  out:;
279 }
280
281 static void dump_pria(struct polypath *st, const char *ifname)
282 {
283 #ifdef POLYPATH_DEBUG
284     struct interf *interf;
285     if (ifname)
286         lg_perror(LG,M_DEBUG,0, "polypath record ifaddr `%s'",ifname);
287     LIST_FOREACH(interf, &st->interfs, entry) {
288         lg_perror(LG,M_DEBUG,0, "  polypath interface `%s', nsocks=%d",
289                   interf->name, interf->socks.n_socks);
290         int i;
291         for (i=0; i<interf->socks.n_socks; i++) {
292             struct udpsock *us=&interf->socks.socks[i];
293             lg_perror(LG,M_DEBUG,0, "    polypath sock fd=%d addr=%s",
294                       us->fd, iaddr_to_string(&us->addr));
295         }
296     }
297 #endif
298 }
299
300 static bool_t polypath_make_socket(struct polypath *st,
301                                    bad_fn_type *bad, void *badctx,
302                                    struct udpsock *us, const char *ifname)
303     /* on error exit has called bad; might leave us->fd as -1 */
304 {
305     assert(us->fd==-1);
306
307     bool_t ok=udp_make_socket(&st->uc,us,M_WARNING);
308     if (!ok) BAD("unable to set up socket");
309     int r=setsockopt(us->fd,SOL_SOCKET,SO_BINDTODEVICE,
310                      ifname,strlen(ifname)+1);
311     if (r) BADE("setsockopt(,,SO_BINDTODEVICE,)",errno);
312     return True;
313
314  out:
315     return False;
316 }
317
318 static void polypath_record_ifaddr(struct polypath *st,
319                                    bad_fn_type *bad, void *badctx,
320                                    bool_t add, const char *ifname,
321                                    const char *ifaddr,
322                                    const union iaddr *ia, int fd)
323 {
324     struct udpcommon *uc=&st->uc;
325     struct interf *interf=0;
326     struct udpsock *us=0;
327
328     dump_pria(st,ifname);
329
330     int n_ifs=0;
331     LIST_FOREACH(interf,&st->interfs,entry) {
332         if (!strcmp(interf->name,ifname))
333             goto found_interf;
334         n_ifs++;
335     }
336     /* not found */
337     if (n_ifs==st->max_interfs) BAD("too many interfaces");
338     interf=malloc(sizeof(*interf));
339     if (!interf) BADE("malloc for new interface",errno);
340     interf->name=0;
341     interf->socks.n_socks=0;
342     FILLZERO(interf->experienced_xmit_noaf);
343     LIST_INSERT_HEAD(&st->interfs,interf,entry);
344     interf->name=strdup(ifname);
345     udp_socks_register(&st->uc,&interf->socks,interf->name);
346     if (!interf->name) BADE("strdup interface name",errno);
347  found_interf:
348
349     if (add) {
350         if (interf->socks.n_socks == UDP_MAX_SOCKETS)
351             BAD("too many addresses on this interface");
352         struct udpsock *us=&interf->socks.socks[interf->socks.n_socks];
353         us->fd=-1;
354         COPY_OBJ(us->addr,*ia);
355         if (fd<0) {
356             bool_t ok=polypath_make_socket(st,bad,badctx, us,ifname);
357             if (!ok) goto out;
358         } else {
359             bool_t ok=udp_import_socket(uc,us,M_WARNING,fd);
360             if (!ok) goto out;
361             fd=-1;
362         }
363         interf->socks.n_socks++;
364         lg_perror(LG,M_INFO,0,"using %s %s",ifname,
365                   iaddr_to_string(&us->addr));
366         us=0; /* do not destroy this socket during `out' */
367     } else {
368         int i;
369         for (i=0; i<interf->socks.n_socks; i++)
370             if (iaddr_equal(&interf->socks.socks[i].addr,ia,True))
371                 goto address_remove_found;
372         bad(st,badctx,M_DEBUG,"address to remove not found",0);
373         goto out;
374     address_remove_found:
375         lg_perror(LG,M_INFO,0,"removed %s %s",ifname,
376                   iaddr_to_string(&interf->socks.socks[i].addr));
377         udp_destroy_socket(&st->uc,&interf->socks.socks[i]);
378         interf->socks.socks[i]=
379             interf->socks.socks[--interf->socks.n_socks];
380     }
381
382  out:
383     if (us)
384         udp_destroy_socket(uc,us);
385     if (fd>=0)
386         close(fd);
387     if (interf && !interf->socks.n_socks) {
388         udp_socks_deregister(&st->uc,&interf->socks);
389         LIST_REMOVE(interf,entry);
390         free(interf->name);
391         free(interf);
392     }
393
394     dump_pria(st,0);
395 }
396
397 static void subproc_problem(struct polypath *st,
398                             enum async_linebuf_result alr, const char *emsg)
399 {
400     int status;
401     assert(st->monitor_pid);
402
403     pid_t gotpid=waitpid(st->monitor_pid,&status,WNOHANG);
404     if (gotpid==st->monitor_pid) {
405         st->monitor_pid=0;
406         lg_exitstatus(LG,M_FATAL,status,"interface monitor");
407     } else if (gotpid<0)
408         lg_perror(LG,M_ERR,errno,"unable to reap interface monitor");
409     else
410         assert(gotpid==0);
411
412     if (alr==async_linebuf_eof)
413         lg_perror(LG,M_FATAL,0,"unexpected EOF from interface monitor");
414     else
415         lg_perror(LG,M_FATAL,0,"bad output from interface monitor: %s",emsg);
416     assert(!"not reached");
417 }
418
419 /* Used in non-privsep case, and in privsep child */
420 static void afterpoll_monitor(struct polypath *st, struct pollfd *fd,
421                               polypath_ppml_callback_type *callback)
422 {
423     enum async_linebuf_result alr;
424     const char *emsg;
425     
426     while ((alr=async_linebuf_read(fd,&st->lbuf,&emsg)) == async_linebuf_ok)
427         polypath_process_monitor_line(st,st->lbuf.base,callback);
428
429     if (alr==async_linebuf_nothing)
430         return;
431
432     subproc_problem(st,alr,emsg);
433 }
434
435 /* Used in non-privsep case only - glue for secnet main loop */
436 static void polypath_afterpoll_monitor(void *state, struct pollfd *fds,
437                                        int nfds)
438 {
439     struct polypath *st=state;
440     if (nfds<1) return;
441     afterpoll_monitor(st,fds,polypath_record_ifaddr);
442 }
443
444 /* Actual udp packet sending work */
445 static bool_t polypath_sendmsg(void *commst, struct buffer_if *buf,
446                           const struct comm_addr *dest)
447 {
448     struct polypath *st=commst;
449     struct interf *interf;
450     bool_t allreasonable=True;
451     int af=dest->ia.sa.sa_family;
452
453     LIST_FOREACH(interf,&st->interfs,entry) {
454         int i;
455         bool_t attempted=False, reasonable=False;
456         for (i=0; i<interf->socks.n_socks; i++) {
457             struct udpsock *us=&interf->socks.socks[i];
458             if (af != us->addr.sa.sa_family)
459                 continue;
460             attempted=True;
461             int r=sendto(us->fd,buf->start,buf->size,
462                          0,&dest->ia.sa,iaddr_socklen(&dest->ia));
463             udp_sock_experienced(0,&st->uc,&interf->socks,us,
464                                  &dest->ia,af, r,errno);
465             if (r>=0) {
466                 reasonable=True;
467                 break;
468             }
469             if (!(errno==EAFNOSUPPORT || errno==ENETUNREACH))
470                 reasonable=True;
471             lg_perror(LG,M_DEBUG,errno,"%s [%s] xmit %"PRIu32" bytes to %s",
472                       interf->name,iaddr_to_string(&us->addr),
473                       buf->size,iaddr_to_string(&dest->ia));
474         }
475         if (!attempted)
476             if (!interf->experienced_xmit_noaf[af]++)
477                 lg_perror(LG,M_WARNING,0,
478                           "%s has no suitable address to transmit %s",
479                           interf->name, af_name(af));
480         allreasonable *= reasonable;
481     }
482     return allreasonable;
483 }
484
485 /* Non-privsep: called in (sole) child.  Privsep: in grandchild. */
486 static void child_monitor(struct polypath *st, int childfd)
487 {
488     dup2(childfd,1);
489     execvp(st->monitor_command[0],(char**)st->monitor_command);
490     fprintf(stderr,"secnet: cannot execute %s: %s\n",
491             st->monitor_command[0], strerror(errno));
492     exit(-1);
493 }
494
495 /* General utility function. */
496 static void start_subproc(struct polypath *st, void (*make_fdpair)(int[2]),
497                           void (*child)(struct polypath *st, int childfd),
498                           const char *desc)
499 {
500     int pfds[2];
501
502     assert(!st->monitor_pid);
503     assert(st->monitor_fd<0);
504
505     make_fdpair(pfds);
506
507     pid_t pid=fork();
508     if (!pid) {
509         afterfork();
510         close(pfds[0]);
511         child(st,pfds[1]);
512         abort();
513     }
514     if (pid<0)
515         fatal_perror("%s: failed to fork for interface monitoring",
516                      st->uc.cc.cl.description);
517
518     close(pfds[1]);
519     st->monitor_pid=pid;
520     st->monitor_fd=pfds[0];
521     setnonblock(st->monitor_fd);
522
523     lg_perror(LG,M_NOTICE,0, "%s: spawning %s [pid %ld]",
524               st->uc.cc.cl.description, desc, (long)st->monitor_pid);
525 }
526
527 /* Non-privsep only: glue for forking the monitor, from the main loop */
528 static void polypath_phase_startmonitor(void *sst, uint32_t newphase)
529 {
530     struct polypath *st=sst;
531     start_subproc(st,pipe_cloexec,child_monitor,
532                   "interface monitor (no privsep)");
533     register_for_poll(st,polypath_beforepoll,
534                       polypath_afterpoll_monitor,"polypath");
535 }
536
537 /*----- Privsep-only: -----*/
538
539 /*
540  * We use two subprocesses, a child and a grandchild.  These are
541  * forked before secnet drops privilege.
542  *
543  * The grandchild is the same interface monitor helper script as used
544  * in the non-privsep case.  But its lines are read by the child
545  * instead of by the main secnet.  The child is responsible for
546  * creating the actual socket (binding it, etc.).  Each socket is
547  * passed to secnet proper via fd passing, along with a data message
548  * describing the interface name and address.  The child does not
549  * retain a list of current interfaces and addresses - it trusts the
550  * interface monitor to get that right.  secnet proper still maintains
551  * that data structure.
552  *
553  * The result is that much of the non-privsep code can be reused, but
554  * just plumbed together differently.
555  *
556  * The child does not retain the socket after passing it on.
557  * Interface removals are handled similarly but without any fd.
558  *
559  * The result is that the configuration's limits on which interfaces
560  * and ports secnet may use are enforced by the privileged child.
561  */
562
563 struct privsep_mdata {
564     bool_t add;
565     char ifname[100];
566     union iaddr ia;
567 };
568
569 static void papp_bad(struct polypath *st, void *badctx,
570                      int mclass, const char *m, int ev)
571 {
572     const struct privsep_mdata *mdata=(const void*)st->lbuf.start;
573     const char *addr_str=badctx;
574
575     lg_perror(LG,mclass,ev,
576               "error processing polypath address change %s %s [%s]: %s",
577               mdata->add ? "+" : "-",
578               mdata->ifname, addr_str, m);
579 }
580
581 static void polypath_afterpoll_privsep(void *state, struct pollfd *fds,
582                                        int nfds)
583 /* In secnet proper; receives messages from child. */
584 {
585     struct polypath *st=state;
586
587     if (nfds<1) return;
588
589     int revents=fds[0].revents;
590
591     const char *badbit=pollbadbit(revents);
592     if (badbit) subproc_problem(st,async_linebuf_broken,badbit);
593
594     if (!(revents & POLLIN)) return;
595
596     for (;;) {
597         if (st->lbuf.size==sizeof(struct privsep_mdata)) {
598             const struct privsep_mdata *mdata=(const void*)st->lbuf.start;
599             if (mdata->add && st->privsep_incoming_fd<0)
600                 fatal("polypath (privsep): got add message data but no fd");
601             if (!mdata->add && st->privsep_incoming_fd>=0)
602                 fatal("polypath (privsep): got remove message data with fd");
603             if (!memchr(mdata->ifname,0,sizeof(mdata->ifname)))
604                 fatal("polypath (privsep): got ifname with no terminating nul");
605             int af=mdata->ia.sa.sa_family;
606             if (!(af==AF_INET6 || af==AF_INET))
607                 fatal("polypath (privsep): got message data but bad AF %d",af);
608             const char *addr_str=iaddr_to_string(&mdata->ia);
609             polypath_record_ifaddr(st,papp_bad,(void*)addr_str,
610                                    mdata->add,mdata->ifname,addr_str,
611                                    &mdata->ia, st->privsep_incoming_fd);
612             st->privsep_incoming_fd=-1;
613             st->lbuf.size=0;
614         }
615         struct msghdr msg;
616         int fd;
617         size_t cmsgdatalen=sizeof(fd);
618         char cmsg_control_buf[CMSG_SPACE(cmsgdatalen)];
619         struct iovec iov;
620
621         FILLZERO(msg);
622         msg.msg_iov=&iov;
623         msg.msg_iovlen=1;
624
625         iov.iov_base=st->lbuf.start+st->lbuf.size;
626         iov.iov_len=sizeof(struct privsep_mdata)-st->lbuf.size;
627
628         if (st->privsep_incoming_fd<0) {
629             msg.msg_control=cmsg_control_buf;
630             msg.msg_controllen=sizeof(cmsg_control_buf);
631         }
632
633         ssize_t got=recvmsg(st->monitor_fd,&msg,0);
634         if (got<0) {
635             if (errno==EINTR) continue;
636             if (iswouldblock(errno)) break;
637             fatal_perror("polypath (privsep): recvmsg failed");
638         }
639         if (got==0)
640             subproc_problem(st,async_linebuf_eof,0);
641
642         st->lbuf.size+=got;
643
644         if (msg.msg_controllen) {
645             size_t cmsgdatalen=sizeof(st->privsep_incoming_fd);
646             struct cmsghdr *h=CMSG_FIRSTHDR(&msg);
647             if (!(st->privsep_incoming_fd==-1 &&
648                   h &&
649                   h->cmsg_level==SOL_SOCKET &&
650                   h->cmsg_type==SCM_RIGHTS &&
651                   h->cmsg_len==CMSG_LEN(cmsgdatalen) &&
652                   !CMSG_NXTHDR(&msg,h)))
653                 subproc_problem(st,async_linebuf_broken,"bad cmsg");
654             memcpy(&st->privsep_incoming_fd,CMSG_DATA(h),cmsgdatalen);
655             assert(st->privsep_incoming_fd>=0);
656         }
657
658     }
659 }
660
661 static void privsep_handle_ifaddr(struct polypath *st,
662                                    bad_fn_type *bad, void *badctx,
663                                    bool_t add, const char *ifname,
664                                    const char *ifaddr,
665                                    const union iaddr *ia, int fd_dummy)
666 /* In child: handles discovered wanted interfaces, making sockets
667    and sending them to secnet proper. */
668 {
669     struct msghdr msg;
670     struct iovec iov;
671     struct udpsock us={ .fd=-1 };
672     size_t cmsgdatalen=sizeof(us.fd);
673     char cmsg_control_buf[CMSG_SPACE(cmsgdatalen)];
674
675     assert(fd_dummy==-1);
676
677     struct privsep_mdata mdata;
678     FILLZERO(mdata);
679     mdata.add=add;
680
681     size_t l=strlen(ifname);
682     if (l>=sizeof(mdata.ifname)) BAD("interface name too long");
683     strcpy(mdata.ifname,ifname);
684
685     COPY_OBJ(mdata.ia,*ia);
686
687     iov.iov_base=&mdata;
688     iov.iov_len =sizeof(mdata);
689
690     FILLZERO(msg);
691     msg.msg_iov=&iov;
692     msg.msg_iovlen=1;
693
694     if (add) {
695         COPY_OBJ(us.addr,*ia);
696         bool_t ok=polypath_make_socket(st,bad,badctx,&us,ifname);
697         if (!ok) goto out;
698
699         msg.msg_control=cmsg_control_buf;
700         msg.msg_controllen=sizeof(cmsg_control_buf);
701
702         struct cmsghdr *h=CMSG_FIRSTHDR(&msg);
703         h->cmsg_level=SOL_SOCKET;
704         h->cmsg_type =SCM_RIGHTS;
705         h->cmsg_len  =CMSG_LEN(cmsgdatalen);
706         memcpy(CMSG_DATA(h),&us.fd,cmsgdatalen);
707     }
708
709     while (iov.iov_len) {
710         ssize_t got=sendmsg(st->privsep_ipcsock_fd,&msg,0);
711         if (got<0) {
712             if (errno!=EINTR) fatal_perror("polypath privsep sendmsg");
713             got=0;
714         } else {
715             assert(got>0);
716             assert((size_t)got<=iov.iov_len);
717         }
718         iov.iov_base=(char*)iov.iov_base+got;
719         iov.iov_len-=got;
720         msg.msg_control=0;
721         msg.msg_controllen=0;
722     }
723
724  out:
725     if (us.fd>=0) close(us.fd);
726 }
727
728 static void child_privsep(struct polypath *st, int ipcsockfd)
729 /* Privsep child main loop. */
730 {
731     struct pollfd fds[2];
732
733     enter_phase(PHASE_CHILDPERSIST);
734
735     st->privsep_ipcsock_fd=ipcsockfd;
736     start_subproc(st,pipe_cloexec,child_monitor,
737                   "interface monitor (grandchild)");
738     for (;;) {
739         int nfds=1;
740         int r=polypath_beforepoll(st,fds,&nfds,0);
741         assert(nfds==1);
742         assert(!r);
743
744         fds[1].fd=st->privsep_ipcsock_fd;
745         fds[1].events=POLLIN;
746
747         r=poll(fds,ARRAY_SIZE(fds),-1);
748
749         if (r<0) {
750             if (errno==EINTR) continue;
751             fatal_perror("polypath privsep poll");
752         }
753         if (fds[1].revents) {
754             if (fds[1].revents & (POLLHUP|POLLIN)) {
755                 polypath_phase_shutdown(st,PHASE_SHUTDOWN);
756                 exit(0);
757             }
758             fatal("polypath privsep poll parent socket revents=%#x",
759                   fds[1].revents);
760         }
761         if (fds[0].revents & POLLNVAL)
762             fatal("polypath privsep poll child socket POLLNVAL");
763         afterpoll_monitor(st,fds,privsep_handle_ifaddr);
764     }
765 }
766
767 static void privsep_socketpair(int *fd)
768 {
769     int r=socketpair(AF_UNIX,SOCK_STREAM,0,fd);
770     if (r) fatal_perror("socketpair(AF_UNIX,SOCK_STREAM,,)");
771     setcloexec(fd[0]);
772     setcloexec(fd[1]);
773 }
774
775 static void polypath_phase_startprivsep(void *sst, uint32_t newphase)
776 {
777     struct polypath *st=sst;
778
779     if (!will_droppriv()) {
780         add_hook(PHASE_RUN,          polypath_phase_startmonitor,st);
781         return;
782     }
783
784     start_subproc(st,privsep_socketpair,child_privsep,
785                   "socket generator (privsep interface handler)");
786
787     BUF_FREE(&st->lbuf);
788     buffer_destroy(&st->lbuf);
789     buffer_new(&st->lbuf,sizeof(struct privsep_mdata));
790     BUF_ALLOC(&st->lbuf,"polypath mdata buf");
791     st->privsep_incoming_fd=-1;
792
793     register_for_poll(st,polypath_beforepoll,
794                       polypath_afterpoll_privsep,"polypath");
795 }
796
797 static void polypath_phase_shutdown(void *sst, uint32_t newphase)
798 {
799     struct polypath *st=sst;
800     if (st->monitor_pid) {
801         assert(st->monitor_pid>0);
802         kill(st->monitor_pid,SIGTERM);
803     }
804 }
805
806 static void polypath_phase_childpersist(void *sst, uint32_t newphase)
807 {
808     struct polypath *st=sst;
809     struct interf *interf;
810
811     LIST_FOREACH(interf,&st->interfs,entry)
812         udp_socks_childpersist(&st->uc,&interf->socks);
813 }
814
815 #undef BAD
816 #undef BADE
817
818 /*----- generic closure and module setup -----*/
819
820 static list_t *polypath_apply(closure_t *self, struct cloc loc,
821                               dict_t *context, list_t *args)
822 {
823     struct polypath *st;
824
825     COMM_APPLY(st,&st->uc.cc,polypath_,"polypath",loc);
826     COMM_APPLY_STANDARD(st,&st->uc.cc,"polypath",args);
827     UDP_APPLY_STANDARD(st,&st->uc,"polypath");
828
829     struct udpcommon *uc=&st->uc;
830     struct commcommon *cc=&uc->cc;
831
832     st->max_interfs=dict_read_number(d,"max-interfaces",False,"polypath",loc,3);
833
834     st->ifname_pats=dict_read_string_array(d,"interfaces",False,"polypath",
835                                            cc->loc,0);
836     st->permit_loopback=0; /* ifname_wanted reads this */
837     ifname_wanted(st,st->uc.cc.loc," "); /* try to check each pattern */
838
839     st->monitor_command=dict_read_string_array(d,"monitor-command",False,
840                                "polypath",cc->loc, default_monitor_command);
841     if (!st->monitor_command[0])
842         cfgfatal(loc,"polypath","no polypath interface monitor-command"
843                  " (polypath unsupported on this platform?)\n");
844
845     st->permit_loopback=dict_read_bool(d,"permit-loopback",False,
846                                        "polypath",cc->loc,False);
847
848     LIST_INIT(&st->interfs);
849     buffer_new(&st->lbuf,ADNS_ADDR2TEXT_BUFLEN+100);
850     BUF_ALLOC(&st->lbuf,"polypath lbuf");
851
852     st->monitor_fd=-1;
853     st->monitor_pid=0;
854
855     add_hook(PHASE_GETRESOURCES, polypath_phase_startprivsep,st);
856
857     add_hook(PHASE_SHUTDOWN,    polypath_phase_shutdown,    st);
858     add_hook(PHASE_CHILDPERSIST,polypath_phase_childpersist,st);
859
860     return new_closure(&cc->cl);
861 }
862
863 #endif /* CONFIG_IPV6 */
864
865 void polypath_module(dict_t *dict)
866 {
867 #ifdef CONFIG_IPV6
868     add_closure(dict,"polypath",polypath_apply);
869 #endif /* CONFIG_IPV6 */
870 }