/* $OpenBSD: rebound.c,v 1.98 2018/05/01 15:14:43 anton Exp $ */ /* * Copyright (c) 2015 Ted Unangst * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define MINIMUM(a,b) (((a)<(b))?(a):(b)) uint16_t randomid(void); union sockun { struct sockaddr a; struct sockaddr_storage s; struct sockaddr_in i; struct sockaddr_in6 i6; }; static struct timespec now; static int debug; static int daemonized; struct dnspacket { uint16_t id; uint16_t flags; uint16_t qdcount; uint16_t ancount; uint16_t nscount; uint16_t arcount; char qname[]; /* ... */ }; #define NAMELEN 256 /* * requests will point to cache entries until a response is received. * until then, the request owns the entry and must free it. * after the response is set, the request must not free it. */ struct dnscache { TAILQ_ENTRY(dnscache) fifo; RB_ENTRY(dnscache) cachenode; struct dnspacket *req; size_t reqlen; struct dnspacket *resp; size_t resplen; struct timespec ts; struct timespec basetime; int permanent; }; static TAILQ_HEAD(, dnscache) cachefifo; static RB_HEAD(cachetree, dnscache) cachetree; RB_PROTOTYPE_STATIC(cachetree, dnscache, cachenode, cachecmp) static int cachecount; static int cachemax; static uint64_t cachehits; /* * requests are kept on a fifo list, but only after socket s is set. */ struct request { int s; int client; int tcp; union sockun from; socklen_t fromlen; struct timespec ts; TAILQ_ENTRY(request) fifo; uint16_t clientid; uint16_t reqid; struct dnscache *cacheent; char origname[NAMELEN]; char newname[NAMELEN]; }; static TAILQ_HEAD(, request) reqfifo; static int conncount; static int connmax; static uint64_t conntotal; static int stopaccepting; static void logmsg(int prio, const char *msg, ...) { va_list ap; if (debug || !daemonized) { va_start(ap, msg); vfprintf(stdout, msg, ap); fprintf(stdout, "\n"); va_end(ap); } if (!debug) { va_start(ap, msg); vsyslog(LOG_DAEMON | prio, msg, ap); va_end(ap); } } static void __dead logerr(const char *msg, ...) { va_list ap; if (debug || !daemonized) { va_start(ap, msg); fprintf(stderr, "rebound: "); vfprintf(stderr, msg, ap); fprintf(stderr, "\n"); va_end(ap); } if (!debug) { va_start(ap, msg); vsyslog(LOG_DAEMON | LOG_ERR, msg, ap); va_end(ap); } exit(1); } static int cachecmp(struct dnscache *c1, struct dnscache *c2) { if (c1->reqlen == c2->reqlen) return memcmp(c1->req, c2->req, c1->reqlen); return c1->reqlen < c2->reqlen ? -1 : 1; } RB_GENERATE_STATIC(cachetree, dnscache, cachenode, cachecmp) static void lowercase(unsigned char *s, size_t len) { while (len--) { *s = tolower(*s); s++; } } static void randomcase(unsigned char *s, size_t len) { unsigned char bits[NAMELEN / 8], *b; u_int i = 0; arc4random_buf(bits, (len + 7) / 8); b = bits; while (len--) { *s = (*b & (1 << i)) ? toupper(*s) : tolower(*s); s++; i++; if (i == 8) { b++; i = 0; } } } static void freecacheent(struct dnscache *ent) { cachecount -= 1; RB_REMOVE(cachetree, &cachetree, ent); TAILQ_REMOVE(&cachefifo, ent, fifo); free(ent->req); free(ent->resp); free(ent); } /* * names end with either a nul byte, or a two byte 0xc0 pointer */ static size_t dnamelen(const unsigned char *p, size_t len) { size_t n = 0; for (n = 0; n < len; n++) { if (p[n] == 0) return n + 1; if ((p[n] & 0xc0) == 0xc0) return n + 2; } return len + 1; } static int adjustttl(struct dnscache *ent) { struct dnspacket *resp = ent->resp; char *p = (char *)resp; u_int rlen = ent->resplen; u_int used = 0; uint32_t ttl, cnt, i; uint16_t len; time_t diff; if (ent->permanent) return 0; diff = now.tv_sec - ent->basetime.tv_sec; if (diff <= 0) return 0; /* checks are redundant; checked when cacheent is created */ /* skip past packet header */ used += sizeof(struct dnspacket); if (used >= rlen) return -1; if (ntohs(resp->qdcount) != 1) return -1; /* skip past query name, type, and class */ used += dnamelen(p + used, rlen - used); used += 2; used += 2; cnt = ntohs(resp->ancount); for (i = 0; i < cnt; i++) { if (used >= rlen) return -1; /* skip past answer name, type, and class */ used += dnamelen(p + used, rlen - used); used += 2; used += 2; if (used + 4 >= rlen) return -1; memcpy(&ttl, p + used, 4); ttl = ntohl(ttl); /* expired */ if (diff >= ttl) return -1; ttl -= diff; ttl = ntohl(ttl); memcpy(p + used, &ttl, 4); used += 4; if (used + 2 >= rlen) return -1; memcpy(&len, p + used, 2); used += 2; used += ntohs(len); } ent->basetime.tv_sec += diff; return 0; } static struct dnscache * cachelookup(struct dnspacket *dnsreq, size_t reqlen, size_t namelen) { struct dnscache *hit, key; unsigned char origname[NAMELEN]; uint16_t origid; memcpy(origname, dnsreq->qname, namelen); lowercase(dnsreq->qname, namelen); origid = dnsreq->id; dnsreq->id = 0; key.reqlen = reqlen; key.req = dnsreq; hit = RB_FIND(cachetree, &cachetree, &key); if (hit) { if (adjustttl(hit) != 0) { freecacheent(hit); hit = NULL; } else cachehits += 1; } memcpy(dnsreq->qname, origname, namelen); dnsreq->id = origid; return hit; } static void freerequest(struct request *req) { struct dnscache *ent; if (req->tcp) conncount -= 2; else conncount -= 1; if (req->s != -1) { TAILQ_REMOVE(&reqfifo, req, fifo); close(req->s); } if (req->tcp && req->client != -1) close(req->client); if ((ent = req->cacheent) && !ent->resp) { free(ent->req); free(ent); } free(req); } static void servfail(int ud, uint16_t id, struct sockaddr *fromaddr, socklen_t fromlen) { struct dnspacket pkt; memset(&pkt, 0, sizeof(pkt)); pkt.id = id; pkt.flags = htons(1 << 15 | 0x2); sendto(ud, &pkt, sizeof(pkt), 0, fromaddr, fromlen); } static struct request * newrequest(int ud, struct sockaddr *remoteaddr) { union sockun from; socklen_t fromlen; struct request *req; uint8_t buf[65536]; struct dnspacket *dnsreq; struct dnscache *hit = NULL; size_t r; size_t namelen = 0; dnsreq = (struct dnspacket *)buf; fromlen = sizeof(from); r = recvfrom(ud, buf, sizeof(buf), 0, &from.a, &fromlen); if (r == 0 || r == -1 || r < sizeof(struct dnspacket)) return NULL; if (ntohs(dnsreq->qdcount) == 1) { /* some more checking */ namelen = dnamelen(dnsreq->qname, r - sizeof(struct dnspacket)); if (namelen > r - sizeof(struct dnspacket)) return NULL; if (namelen > NAMELEN) return NULL; hit = cachelookup(dnsreq, r, namelen); } conntotal += 1; if (hit) { hit->resp->id = dnsreq->id; memcpy(hit->resp->qname, dnsreq->qname, namelen); sendto(ud, hit->resp, hit->resplen, 0, &from.a, fromlen); return NULL; } if (!(req = calloc(1, sizeof(*req)))) return NULL; conncount += 1; req->ts = now; req->ts.tv_sec += 30; req->s = -1; req->client = ud; memcpy(&req->from, &from, fromlen); req->fromlen = fromlen; req->clientid = dnsreq->id; req->reqid = randomid(); dnsreq->id = req->reqid; if (ntohs(dnsreq->qdcount) == 1) { memcpy(req->origname, dnsreq->qname, namelen); randomcase(dnsreq->qname, namelen); memcpy(req->newname, dnsreq->qname, namelen); hit = calloc(1, sizeof(*hit)); if (hit) { hit->req = malloc(r); if (hit->req) { memcpy(hit->req, dnsreq, r); hit->reqlen = r; hit->req->id = 0; lowercase(hit->req->qname, namelen); } else { free(hit); hit = NULL; } } req->cacheent = hit; } req->s = socket(remoteaddr->sa_family, SOCK_DGRAM, 0); if (req->s == -1) goto fail; TAILQ_INSERT_TAIL(&reqfifo, req, fifo); if (connect(req->s, remoteaddr, remoteaddr->sa_len) == -1) { logmsg(LOG_NOTICE, "failed to connect (%d)", errno); if (errno == EADDRNOTAVAIL) servfail(ud, req->clientid, &from.a, fromlen); goto fail; } if (send(req->s, buf, r, 0) != r) { logmsg(LOG_NOTICE, "failed to send (%d)", errno); goto fail; } return req; fail: freerequest(req); return NULL; } static uint32_t minttl(struct dnspacket *resp, u_int rlen) { uint32_t minttl = -1, ttl, cnt, i; uint16_t len; char *p = (char *)resp; u_int used = 0; /* skip past packet header */ used += sizeof(struct dnspacket); if (used >= rlen) return -1; if (ntohs(resp->qdcount) != 1) return -1; /* skip past query name, type, and class */ used += dnamelen(p + used, rlen - used); used += 2; used += 2; cnt = ntohs(resp->ancount); for (i = 0; i < cnt; i++) { if (used >= rlen) return -1; /* skip past answer name, type, and class */ used += dnamelen(p + used, rlen - used); used += 2; used += 2; if (used + 4 >= rlen) return -1; memcpy(&ttl, p + used, 4); used += 4; if (used + 2 >= rlen) return -1; ttl = ntohl(ttl); if (ttl < minttl) minttl = ttl; memcpy(&len, p + used, 2); used += 2; used += ntohs(len); } return minttl; } static void sendreply(struct request *req) { uint8_t buf[65536]; struct dnspacket *resp; struct dnscache *ent; size_t r; uint32_t ttl; resp = (struct dnspacket *)buf; r = recv(req->s, buf, sizeof(buf), 0); if (r == 0 || r == -1 || r < sizeof(struct dnspacket)) return; if (resp->id != req->reqid) return; resp->id = req->clientid; if (ntohs(resp->qdcount) == 1) { /* some more checking */ size_t namelen = dnamelen(resp->qname, r - sizeof(struct dnspacket)); if (namelen > r - sizeof(struct dnspacket)) return; if (namelen > NAMELEN) return; if (memcmp(resp->qname, req->newname, namelen) != 0) return; memcpy(resp->qname, req->origname, namelen); } sendto(req->client, buf, r, 0, &req->from.a, req->fromlen); if ((ent = req->cacheent)) { /* check that the response is worth caching */ ttl = minttl(resp, r); if (ttl == -1 || ttl == 0) return; /* * we do this next, because there's a potential race against * other requests made at the same time. if we lose, abort. * if anything else goes wrong, though, we need to reverse. */ if (RB_INSERT(cachetree, &cachetree, ent)) return; ent->ts = now; ent->ts.tv_sec += MINIMUM(ttl, 300); ent->basetime = now; ent->resp = malloc(r); if (!ent->resp) { RB_REMOVE(cachetree, &cachetree, ent); return; } memcpy(ent->resp, buf, r); ent->resplen = r; cachecount += 1; TAILQ_INSERT_TAIL(&cachefifo, ent, fifo); } } static struct request * tcpphasetwo(struct request *req) { int error; socklen_t len = sizeof(error); req->tcp = 2; if (getsockopt(req->s, SOL_SOCKET, SO_ERROR, &error, &len) == -1 || error != 0) goto fail; if (setsockopt(req->client, SOL_SOCKET, SO_SPLICE, &req->s, sizeof(req->s)) == -1) goto fail; if (setsockopt(req->s, SOL_SOCKET, SO_SPLICE, &req->client, sizeof(req->client)) == -1) goto fail; return req; fail: freerequest(req); return NULL; } static struct request * newtcprequest(int ld, struct sockaddr *remoteaddr) { struct request *req; int client; client = accept(ld, NULL, 0); if (client == -1) { if (errno == ENFILE || errno == EMFILE) stopaccepting = 1; return NULL; } if (!(req = calloc(1, sizeof(*req)))) { close(client); return NULL; } conntotal += 1; conncount += 2; req->ts = now; req->ts.tv_sec += 30; req->tcp = 1; req->client = client; req->s = socket(remoteaddr->sa_family, SOCK_STREAM | SOCK_NONBLOCK, 0); if (req->s == -1) goto fail; TAILQ_INSERT_TAIL(&reqfifo, req, fifo); if (connect(req->s, remoteaddr, remoteaddr->sa_len) == -1) { if (errno != EINPROGRESS) goto fail; } else { return tcpphasetwo(req); } return req; fail: freerequest(req); return NULL; } static size_t encodename(const char *name, unsigned char *buf) { const char *s = name; const char *dot; unsigned char len; size_t totlen = 0; while (*s) { dot = strchr(s, '.'); if (!dot) break; len = dot - s; *buf++ = len; memcpy(buf, s, len); buf += len; totlen += len + 1; if (*dot == 0) break; s = dot + 1; } *buf = 0; totlen += 1; return totlen; } static void preloadcache(const char *name, uint16_t type, void *rdata, uint16_t rdatalen) { struct dnspacket *req, *resp; size_t reqlen, resplen; struct dnscache *ent; unsigned char *p; uint16_t len, class; uint32_t ttl; /* header + len + name + type + class */ reqlen = sizeof(*req) + 1 + strlen(name) + 2 + 2; req = malloc(reqlen); req->id = 0; req->flags = htons(0x100); req->qdcount = htons(1); req->ancount = 0; req->nscount = 0; req->arcount = 0; p = (char *)req + sizeof(*req); len = encodename(name, p); p += len; memcpy(p, &type, 2); p += 2; class = htons(1); /* IN */ memcpy(p, &class, 2); /* req + name (compressed) + type + class + ttl + len + data */ resplen = reqlen + 2 + 2 + 2 + 4 + 2 + rdatalen; resp = malloc(resplen); memcpy(resp, req, reqlen); resp->flags = htons(0x100 | 0x8000); /* response */ resp->ancount = htons(1); p = (char *)resp + reqlen; len = htons(sizeof(*req)); memcpy(p, &len, 2); *p |= 0xc0; p += 2; memcpy(p, &type, 2); p += 2; memcpy(p, &class, 2); p += 2; ttl = htonl(10); memcpy(p, &ttl, 4); p += 4; len = htons(rdatalen); memcpy(p, &len, 2); p += 2; memcpy(p, rdata, rdatalen); ent = calloc(1, sizeof(*ent)); ent->req = req; ent->reqlen = reqlen; ent->resp = resp; ent->resplen = resplen; ent->permanent = 1; RB_INSERT(cachetree, &cachetree, ent); } static void preloadA(const char *name, const char *ip) { struct in_addr in; inet_aton(ip, &in); preloadcache(name, htons(1), &in, 4); } static void preloadPTR(const char *ip, const char *name) { char ipbuf[256]; char namebuf[256]; struct in_addr in; inet_aton(ip, &in); in.s_addr = swap32(in.s_addr); snprintf(ipbuf, sizeof(ipbuf), "%s.in-addr.arpa.", inet_ntoa(in)); encodename(name, namebuf); preloadcache(ipbuf, htons(12), namebuf, 1 + strlen(namebuf)); } static int readconfig(int conffd, union sockun *remoteaddr) { const char ns[] = "nameserver"; const char rc[] = "record"; char buf[1024]; char *p; struct sockaddr_in *sin = &remoteaddr->i; struct sockaddr_in6 *sin6 = &remoteaddr->i6; FILE *conf; int rv = -1; conf = fdopen(conffd, "r"); while (fgets(buf, sizeof(buf), conf) != NULL) { buf[strcspn(buf, "\n")] = '\0'; if (strncmp(buf, ns, strlen(ns)) == 0) { p = buf + strlen(ns) + 1; while (isspace((unsigned char)*p)) p++; /* this will not end well */ if (strcmp(p, "127.0.0.1") == 0) continue; memset(remoteaddr, 0, sizeof(*remoteaddr)); if (inet_pton(AF_INET, p, &sin->sin_addr) == 1) { sin->sin_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_port = htons(53); rv = AF_INET; } else if (inet_pton(AF_INET6, p, &sin6->sin6_addr) == 1) { sin6->sin6_len = sizeof(*sin6); sin6->sin6_family = AF_INET6; sin6->sin6_port = htons(53); rv = AF_INET6; } } else if (strncmp(buf, rc, strlen(rc)) == 0) { char rectype[16], name[256], value[256]; p = buf + strlen(rc) + 1; memset(rectype, 0, sizeof(rectype)); sscanf(p, "%15s %255s %255s", rectype, name, value); if (strcmp(rectype, "A") == 0) { if (strlen(name) < 2 || name[strlen(name) - 1] != '.') { logmsg(LOG_ERR, "do not like name %s", name); continue; } preloadA(name, value); preloadPTR(value, name); } } } fclose(conf); return rv; } static void workerinit(void) { struct rlimit rlim; struct passwd *pwd; if (getrlimit(RLIMIT_NOFILE, &rlim) == -1) logerr("getrlimit: %s", strerror(errno)); rlim.rlim_cur = rlim.rlim_max; if (setrlimit(RLIMIT_NOFILE, &rlim) == -1) logerr("setrlimit: %s", strerror(errno)); connmax = rlim.rlim_cur - 10; if (connmax > 512) connmax = 512; cachemax = 10000; /* something big, but not huge */ TAILQ_INIT(&reqfifo); TAILQ_INIT(&cachefifo); RB_INIT(&cachetree); if (!(pwd = getpwnam("_rebound"))) logerr("getpwnam failed"); if (chroot(pwd->pw_dir) == -1) logerr("chroot: %s", strerror(errno)); if (chdir("/") == -1) logerr("chdir: %s", strerror(errno)); setproctitle("worker"); if (setgroups(1, &pwd->pw_gid) || setresgid(pwd->pw_gid, pwd->pw_gid, pwd->pw_gid) || setresuid(pwd->pw_uid, pwd->pw_uid, pwd->pw_uid)) logerr("failed to privdrop"); if (pledge("stdio inet", NULL) == -1) logerr("pledge failed"); } static int workerloop(int conffd, int ud, int ld, int ud6, int ld6) { union sockun remoteaddr; struct kevent ch[2], kev[4]; struct timespec ts, *timeout = NULL; struct request *req; struct dnscache *ent; int i, r, af, kq; kq = kqueue(); if (!debug) { pid_t parent = getppid(); /* would need pledge(proc) to do this below */ EV_SET(&kev[0], parent, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL); if (kevent(kq, kev, 1, NULL, 0, NULL) == -1) logerr("kevent1: %d", errno); } workerinit(); af = readconfig(conffd, &remoteaddr); if (af == -1) logerr("parse error in config file"); EV_SET(&kev[0], ud, EVFILT_READ, EV_ADD, 0, 0, NULL); EV_SET(&kev[1], ld, EVFILT_READ, EV_ADD, 0, 0, NULL); EV_SET(&kev[2], ud6, EVFILT_READ, EV_ADD, 0, 0, NULL); EV_SET(&kev[3], ld6, EVFILT_READ, EV_ADD, 0, 0, NULL); if (kevent(kq, kev, 4, NULL, 0, NULL) == -1) logerr("kevent4: %d", errno); EV_SET(&kev[0], SIGHUP, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); EV_SET(&kev[1], SIGUSR1, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); if (kevent(kq, kev, 2, NULL, 0, NULL) == -1) logerr("kevent2: %d", errno); logmsg(LOG_INFO, "worker process going to work"); while (1) { r = kevent(kq, NULL, 0, kev, 4, timeout); if (r == -1) logerr("kevent failed (%d)", errno); clock_gettime(CLOCK_MONOTONIC, &now); if (stopaccepting) { EV_SET(&ch[0], ld, EVFILT_READ, EV_ADD, 0, 0, NULL); kevent(kq, ch, 1, NULL, 0, NULL); stopaccepting = 0; } for (i = 0; i < r; i++) { struct kevent *ke = &kev[i]; switch (ke->filter) { case EVFILT_SIGNAL: if (ke->ident == SIGHUP) { logmsg(LOG_INFO, "hupped, exiting"); exit(0); } else { logmsg(LOG_INFO, "connection stats: " "%d active, %llu total", conncount, conntotal); logmsg(LOG_INFO, "cache stats: " "%d active, %llu hits", cachecount, cachehits); } break; case EVFILT_PROC: logmsg(LOG_INFO, "parent died"); exit(0); break; case EVFILT_WRITE: req = ke->udata; req = tcpphasetwo(req); if (req) { EV_SET(&ch[0], req->s, EVFILT_WRITE, EV_DELETE, 0, 0, NULL); EV_SET(&ch[1], req->s, EVFILT_READ, EV_ADD, 0, 0, req); kevent(kq, ch, 2, NULL, 0, NULL); } break; case EVFILT_READ: if (ke->ident == ud || ke->ident == ud6) { if ((req = newrequest(ke->ident, &remoteaddr.a))) { EV_SET(&ch[0], req->s, EVFILT_READ, EV_ADD, 0, 0, req); kevent(kq, ch, 1, NULL, 0, NULL); } } else if (ke->ident == ld || ke->ident == ld6) { if ((req = newtcprequest(ke->ident, &remoteaddr.a))) { EV_SET(&ch[0], req->s, req->tcp == 1 ? EVFILT_WRITE : EVFILT_READ, EV_ADD, 0, 0, req); kevent(kq, ch, 1, NULL, 0, NULL); } } else { req = ke->udata; if (req->tcp == 0) sendreply(req); freerequest(req); } break; default: logerr("don't know what happened"); break; } } timeout = NULL; if (stopaccepting) { EV_SET(&ch[0], ld, EVFILT_READ, EV_DELETE, 0, 0, NULL); kevent(kq, ch, 1, NULL, 0, NULL); memset(&ts, 0, sizeof(ts)); /* one second added below */ timeout = &ts; } while (conncount > connmax) freerequest(TAILQ_FIRST(&reqfifo)); while (cachecount > cachemax) freecacheent(TAILQ_FIRST(&cachefifo)); /* burn old cache entries */ while ((ent = TAILQ_FIRST(&cachefifo))) { if (timespeccmp(&ent->ts, &now, <=)) freecacheent(ent); else break; } if (ent) { timespecsub(&ent->ts, &now, &ts); timeout = &ts; } /* burn stalled requests */ while ((req = TAILQ_FIRST(&reqfifo))) { if (timespeccmp(&req->ts, &now, <=)) freerequest(req); else break; } if (req && (!ent || timespeccmp(&req->ts, &ent->ts, <=))) { timespecsub(&req->ts, &now, &ts); timeout = &ts; } /* one second grace to avoid spinning */ if (timeout) timeout->tv_sec += 1; } /* not reached */ exit(1); } static int openconfig(const char *confname, int kq) { struct kevent kev; int conffd; conffd = open(confname, O_RDONLY); if (conffd == -1) logerr("failed to open config %s", confname); if (kq != -1) { EV_SET(&kev, conffd, EVFILT_VNODE, EV_ADD, NOTE_DELETE | NOTE_ATTRIB, 0, NULL); kevent(kq, &kev, 1, NULL, 0, NULL); } return conffd; } static pid_t reexec(int conffd, int ud, int ld, int ud6, int ld6) { pid_t child; if (conffd != 8 || ud != 3 || ld != 4 || ud6 != 5 || ld6 != 6) logerr("can't re-exec, fds are wrong"); switch ((child = fork())) { case -1: logerr("failed to fork"); break; case 0: execl("/usr/sbin/rebound", "rebound", "-W", NULL); logerr("re-exec failed"); default: break; } return child; } static int monitorloop(int ud, int ld, int ud6, int ld6, const char *confname) { pid_t child; struct kevent kev; int r, kq; int conffd = -1; struct timespec ts, *timeout = NULL; if (pledge("stdio rpath proc exec", NULL) == -1) err(1, "pledge"); kq = kqueue(); /* catch these signals with kevent */ signal(SIGHUP, SIG_IGN); EV_SET(&kev, SIGHUP, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); kevent(kq, &kev, 1, NULL, 0, NULL); signal(SIGTERM, SIG_IGN); EV_SET(&kev, SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); kevent(kq, &kev, 1, NULL, 0, NULL); while (1) { int hupped = 0; int childdead = 0; if (conffd == -1) conffd = openconfig(confname, kq); child = reexec(conffd, ud, ld, ud6, ld6); /* monitor child */ EV_SET(&kev, child, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL); kevent(kq, &kev, 1, NULL, 0, NULL); /* wait for something to happen: HUP or child exiting */ timeout = NULL; while (1) { r = kevent(kq, NULL, 0, &kev, 1, timeout); if (r == -1) logerr("kevent failed (%d)", errno); if (r == 0) { /* timeout expired */ logerr("child died without HUP"); } switch (kev.filter) { case EVFILT_VNODE: /* config file changed */ logmsg(LOG_INFO, "config changed, reloading"); sleep(1); raise(SIGHUP); break; case EVFILT_SIGNAL: if (kev.ident == SIGHUP) { /* signaled. kill child. */ logmsg(LOG_INFO, "received HUP, restarting"); close(conffd); conffd = -1; hupped = 1; if (childdead) goto doublebreak; kill(child, SIGHUP); } else if (kev.ident == SIGTERM) { /* good bye */ logmsg(LOG_INFO, "received TERM, quitting"); kill(child, SIGTERM); exit(0); } break; case EVFILT_PROC: /* child died. wait for our own HUP. */ logmsg(LOG_INFO, "observed child exit"); childdead = 1; if (hupped) goto doublebreak; memset(&ts, 0, sizeof(ts)); ts.tv_sec = 1; timeout = &ts; break; default: logerr("don't know what happened"); break; } } doublebreak: while (waitpid(child, NULL, 0) == -1) { if (errno != EINTR) break; } } return 1; } static void __dead usage(void) { fprintf(stderr, "usage: rebound [-d] [-c config] [-l address]\n"); exit(1); } int main(int argc, char **argv) { union sockun bindaddr; int ld, ld6, ud, ud6, ch; int one = 1; const char *confname = "/etc/resolv.conf"; const char *bindname = "127.0.0.1"; tzset(); openlog("rebound", LOG_PID | LOG_NDELAY, LOG_DAEMON); signal(SIGPIPE, SIG_IGN); signal(SIGUSR1, SIG_IGN); while ((ch = getopt(argc, argv, "c:dl:W")) != -1) { switch (ch) { case 'c': confname = optarg; break; case 'd': debug = 1; break; case 'l': bindname = optarg; break; case 'W': daemonized = 1; /* parent responsible for setting up fds */ return workerloop(8, 3, 4, 5, 6); default: usage(); break; } } argv += optind; argc -= optind; if (argc) usage(); /* make sure we consistently open fds */ closefrom(3); memset(&bindaddr, 0, sizeof(bindaddr)); bindaddr.i.sin_len = sizeof(bindaddr.i); bindaddr.i.sin_family = AF_INET; bindaddr.i.sin_port = htons(53); inet_aton(bindname, &bindaddr.i.sin_addr); ud = socket(AF_INET, SOCK_DGRAM, 0); if (ud == -1) logerr("socket: %s", strerror(errno)); if (bind(ud, &bindaddr.a, bindaddr.a.sa_len) == -1) logerr("bind: %s", strerror(errno)); ld = socket(AF_INET, SOCK_STREAM, 0); if (ld == -1) logerr("socket: %s", strerror(errno)); setsockopt(ld, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); if (bind(ld, &bindaddr.a, bindaddr.a.sa_len) == -1) logerr("bind: %s", strerror(errno)); if (listen(ld, 10) == -1) logerr("listen: %s", strerror(errno)); memset(&bindaddr, 0, sizeof(bindaddr)); bindaddr.i6.sin6_len = sizeof(bindaddr.i6); bindaddr.i6.sin6_family = AF_INET6; bindaddr.i6.sin6_port = htons(53); bindaddr.i6.sin6_addr = in6addr_loopback; ud6 = socket(AF_INET6, SOCK_DGRAM, 0); if (ud6 == -1) logerr("socket: %s", strerror(errno)); if (bind(ud6, &bindaddr.a, bindaddr.a.sa_len) == -1) logerr("bind: %s", strerror(errno)); ld6 = socket(AF_INET6, SOCK_STREAM, 0); if (ld6 == -1) logerr("socket: %s", strerror(errno)); setsockopt(ld6, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); if (bind(ld6, &bindaddr.a, bindaddr.a.sa_len) == -1) logerr("bind: %s", strerror(errno)); if (listen(ld6, 10) == -1) logerr("listen: %s", strerror(errno)); if (debug) { int conffd = openconfig(confname, -1); return workerloop(conffd, ud, ld, ud6, ld6); } if (daemon(0, 0) == -1) logerr("daemon: %s", strerror(errno)); daemonized = 1; return monitorloop(ud, ld, ud6, ld6, confname); }