Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Import dhcpcd-8.1.2 with the following changes: 

* hooks: STOPPED is now run on timeout and exit
 * BSD: Use IP_REVCIF rather than IN_PKTINFO
 * DHCP: When rebinding, ensure we have a DHCP ARP state
 * RA: Sort routers when reachability changes
 * RA: Apply hoplimit, reachable and retrans timer values to kernel
 * RA: Warn if advertised MTU > interface MTU
 * dhcpcd: Report SSID connection to when we gain carrier
 * DHCP: Fix corruption of address flags when renewing
This commit is contained in:
roy 2019-11-13 10:49:19 +00:00
parent 40ee987d84
commit 8105b4b2ec
16 changed files with 556 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
external/bsd/dhcpcd/dist/src/arp.c vendored
View File

@ -206,7 +206,6 @@ arp_validate(const struct interface *ifp, struct arphdr *arp)
return true; return true;
} }
static void static void
arp_packet(struct interface *ifp, uint8_t *data, size_t len) arp_packet(struct interface *ifp, uint8_t *data, size_t len)
{ {
@ -280,9 +279,9 @@ arp_close(struct interface *ifp)
} }
static void static void
arp_tryfree(struct interface *ifp) arp_tryfree(struct iarp_state *state)
{ {
struct iarp_state *state = ARP_STATE(ifp); struct interface *ifp = state->ifp;
/* If there are no more ARP states, close the socket. */ /* If there are no more ARP states, close the socket. */
if (TAILQ_FIRST(&state->arp_states) == NULL) { if (TAILQ_FIRST(&state->arp_states) == NULL) {
@ -302,15 +301,14 @@ arp_tryfree(struct interface *ifp)
static void static void
arp_read(void *arg) arp_read(void *arg)
{ {
struct interface *ifp = arg; struct iarp_state *state = arg;
struct iarp_state *state; struct interface *ifp = state->ifp;
uint8_t buf[ARP_LEN]; uint8_t buf[ARP_LEN];
ssize_t bytes; ssize_t bytes;
/* Some RAW mechanisms are generic file descriptors, not sockets. /* Some RAW mechanisms are generic file descriptors, not sockets.
* This means we have no kernel call to just get one packet, * This means we have no kernel call to just get one packet,
* so we have to process the entire buffer. */ * so we have to process the entire buffer. */
state = ARP_STATE(ifp);
state->bpf_flags &= ~BPF_EOF; state->bpf_flags &= ~BPF_EOF;
state->bpf_flags |= BPF_READING; state->bpf_flags |= BPF_READING;
while (!(state->bpf_flags & BPF_EOF)) { while (!(state->bpf_flags & BPF_EOF)) {
@ -329,7 +327,7 @@ arp_read(void *arg)
if (state != NULL) { if (state != NULL) {
state->bpf_flags &= ~BPF_READING; state->bpf_flags &= ~BPF_READING;
/* Try and free the state if nothing left to do. */ /* Try and free the state if nothing left to do. */
arp_tryfree(ifp); arp_tryfree(state);
} }
} }
@ -343,7 +341,7 @@ arp_open(struct interface *ifp)
state->bpf_fd = bpf_open(ifp, bpf_arp); state->bpf_fd = bpf_open(ifp, bpf_arp);
if (state->bpf_fd == -1) if (state->bpf_fd == -1)
return -1; return -1;
eloop_event_add(ifp->ctx->eloop, state->bpf_fd, arp_read, ifp); eloop_event_add(ifp->ctx->eloop, state->bpf_fd, arp_read, state);
} }
return state->bpf_fd; return state->bpf_fd;
} }
@ -571,6 +569,7 @@ arp_new(struct interface *ifp, const struct in_addr *addr)
logerr(__func__); logerr(__func__);
return NULL; return NULL;
} }
state->ifp = ifp;
state->bpf_fd = -1; state->bpf_fd = -1;
state->bpf_flags = 0; state->bpf_flags = 0;
TAILQ_INIT(&state->arp_states); TAILQ_INIT(&state->arp_states);
@ -618,7 +617,7 @@ arp_free(struct arp_state *astate)
if (astate->free_cb) if (astate->free_cb)
astate->free_cb(astate); astate->free_cb(astate);
free(astate); free(astate);
arp_tryfree(ifp); arp_tryfree(state);
} }
void void

1
external/bsd/dhcpcd/dist/src/arp.h vendored
View File

@ -78,6 +78,7 @@ struct arp_state {
TAILQ_HEAD(arp_statehead, arp_state); TAILQ_HEAD(arp_statehead, arp_state);
struct iarp_state { struct iarp_state {
struct interface *ifp;
int bpf_fd; int bpf_fd;
unsigned int bpf_flags; unsigned int bpf_flags;
struct arp_statehead arp_states; struct arp_statehead arp_states;

6
external/bsd/dhcpcd/dist/src/control.c vendored
View File

@ -274,9 +274,8 @@ control_stop(struct dhcpcd_ctx *ctx)
if (ctx->control_fd == -1) if (ctx->control_fd == -1)
return 0; return 0;
eloop_event_delete(ctx->eloop, ctx->control_fd);
close(ctx->control_fd); control_close(ctx);
ctx->control_fd = -1;
if (unlink(ctx->control_sock) == -1) if (unlink(ctx->control_sock) == -1)
retval = -1; retval = -1;
@ -455,6 +454,7 @@ control_close(struct dhcpcd_ctx *ctx)
{ {
if (ctx->control_fd != -1) { if (ctx->control_fd != -1) {
eloop_event_delete(ctx->eloop, ctx->control_fd);
close(ctx->control_fd); close(ctx->control_fd);
ctx->control_fd = -1; ctx->control_fd = -1;
} }

2
external/bsd/dhcpcd/dist/src/defs.h vendored
View File

@ -29,7 +29,7 @@
#define CONFIG_H #define CONFIG_H
#define PACKAGE "dhcpcd" #define PACKAGE "dhcpcd"
#define VERSION "8.1.1" #define VERSION "8.1.2"
#ifndef CONFIG #ifndef CONFIG
# define CONFIG SYSCONFDIR "/" PACKAGE ".conf" # define CONFIG SYSCONFDIR "/" PACKAGE ".conf"

202
external/bsd/dhcpcd/dist/src/dhcp.c vendored
View File

@ -41,6 +41,10 @@
#include <netinet/udp.h> #include <netinet/udp.h>
#undef __FAVOR_BSD #undef __FAVOR_BSD
#ifdef AF_LINK
# include <net/if_dl.h>
#endif
#include <assert.h> #include <assert.h>
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
@ -132,9 +136,7 @@ static void dhcp_arp_found(struct arp_state *, const struct arp_msg *);
#endif #endif
static void dhcp_handledhcp(struct interface *, struct bootp *, size_t, static void dhcp_handledhcp(struct interface *, struct bootp *, size_t,
const struct in_addr *); const struct in_addr *);
#ifdef IP_PKTINFO
static void dhcp_handleifudp(void *); static void dhcp_handleifudp(void *);
#endif
static int dhcp_initstate(struct interface *); static int dhcp_initstate(struct interface *);
void void
@ -1550,7 +1552,10 @@ dhcp_openudp(struct interface *ifp)
n = 1; n = 1;
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1) if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1)
goto eexit; goto eexit;
#ifdef IP_RECVPKTINFO #ifdef IP_RECVIF
if (setsockopt(s, IPPROTO_IP, IP_RECVIF, &n, sizeof(n)) == -1)
goto eexit;
#else
if (setsockopt(s, IPPROTO_IP, IP_RECVPKTINFO, &n, sizeof(n)) == -1) if (setsockopt(s, IPPROTO_IP, IP_RECVPKTINFO, &n, sizeof(n)) == -1)
goto eexit; goto eexit;
#endif #endif
@ -1647,39 +1652,36 @@ dhcp_makeudppacket(size_t *sz, const uint8_t *data, size_t length,
static ssize_t static ssize_t
dhcp_sendudp(struct interface *ifp, struct in_addr *to, void *data, size_t len) dhcp_sendudp(struct interface *ifp, struct in_addr *to, void *data, size_t len)
{ {
int s; struct sockaddr_in sin = {
struct msghdr msg; .sin_family = AF_INET,
struct sockaddr_in sin; .sin_addr = *to,
struct iovec iov[1]; .sin_port = htons(BOOTPS),
#ifdef HAVE_SA_LEN
.sin_len = sizeof(sin),
#endif
};
struct iovec iov[] = {
{ .iov_base = data, .iov_len = len }
};
struct msghdr msg = {
.msg_name = (void *)&sin,
.msg_namelen = sizeof(sin),
.msg_iov = iov,
.msg_iovlen = 1,
};
struct dhcp_state *state = D_STATE(ifp); struct dhcp_state *state = D_STATE(ifp);
ssize_t r; ssize_t r;
int fd;
iov[0].iov_base = data; fd = state->udp_fd;
iov[0].iov_len = len; if (fd == -1) {
fd = dhcp_openudp(ifp);
memset(&sin, 0, sizeof(sin)); if (fd == -1)
sin.sin_family = AF_INET;
sin.sin_addr = *to;
sin.sin_port = htons(BOOTPS);
#ifdef HAVE_SA_LEN
sin.sin_len = sizeof(sin);
#endif
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&sin;
msg.msg_namelen = sizeof(sin);
msg.msg_iov = iov;
msg.msg_iovlen = 1;
s = state->udp_fd;
if (s == -1) {
s = dhcp_openudp(ifp);
if (s == -1)
return -1; return -1;
} }
r = sendmsg(s, &msg, 0); r = sendmsg(fd, &msg, 0);
if (state->udp_fd == -1) if (state->udp_fd == -1)
close(s); close(fd);
return r; return r;
} }
@ -1780,7 +1782,7 @@ send_message(struct interface *ifp, uint8_t type,
* As such we remove it from consideration without actually * As such we remove it from consideration without actually
* stopping the interface. */ * stopping the interface. */
if (r == -1) { if (r == -1) {
logerr("%s: if_sendraw", ifp->name); logerr("%s: bpf_send", ifp->name);
switch(errno) { switch(errno) {
case ENETDOWN: case ENETDOWN:
case ENETRESET: case ENETRESET:
@ -2257,30 +2259,27 @@ dhcp_bind(struct interface *ifp)
ipv4_applyaddr(ifp); ipv4_applyaddr(ifp);
#ifdef IP_PKTINFO
/* Close the BPF filter as we can now receive DHCP messages /* Close the BPF filter as we can now receive DHCP messages
* on a UDP socket. */ * on a UDP socket. */
if (state->udp_fd == -1 || if (!(state->udp_fd == -1 ||
(state->old != NULL && state->old->yiaddr != state->new->yiaddr)) (state->old != NULL && state->old->yiaddr != state->new->yiaddr)))
{ return;
dhcp_close(ifp); dhcp_close(ifp);
/* If not in master mode, open an address specific socket. */
if (ctx->udp_fd == -1) { /* If not in master mode, open an address specific socket. */
state->udp_fd = dhcp_openudp(ifp); if (ctx->udp_fd != -1)
if (state->udp_fd == -1) { return;
logerr(__func__); state->udp_fd = dhcp_openudp(ifp);
/* Address sharing without master mode is if (state->udp_fd == -1) {
* not supported. It's also possible another logerr(__func__);
* DHCP client could be running which is /* Address sharing without master mode is not supported.
* even worse. * It's also possible another DHCP client could be running,
* We still need to work, so re-open BPF. */ * which is even worse.
dhcp_openbpf(ifp); * We still need to work, so re-open BPF. */
} else dhcp_openbpf(ifp);
eloop_event_add(ctx->eloop, return;
state->udp_fd, dhcp_handleifudp, ifp);
}
} }
#endif eloop_event_add(ctx->eloop, state->udp_fd, dhcp_handleifudp, ifp);
} }
static void static void
@ -2609,6 +2608,11 @@ dhcp_reboot(struct interface *ifp)
ifp->name, inet_ntoa(state->lease.addr)); ifp->name, inet_ntoa(state->lease.addr));
#ifdef ARP #ifdef ARP
#ifndef KERNEL_RFC5227
/* Create the DHCP ARP state so we can defend it. */
(void)dhcp_arp_new(ifp, &state->lease.addr);
#endif
/* If the address exists on the interface and no other interface /* If the address exists on the interface and no other interface
* is currently using it then announce it to ensure this * is currently using it then announce it to ensure this
* interface gets the reply. */ * interface gets the reply. */
@ -3315,7 +3319,7 @@ checksums_valid(void *packet,
struct ip *ip = packet; struct ip *ip = packet;
union pip { union pip {
struct ip ip; struct ip ip;
uint16_t w[sizeof(struct ip)]; uint16_t w[sizeof(struct ip) / 2];
} pip = { } pip = {
.ip.ip_p = IPPROTO_UDP, .ip.ip_p = IPPROTO_UDP,
.ip.ip_src = ip->ip_src, .ip.ip_src = ip->ip_src,
@ -3350,7 +3354,7 @@ checksums_valid(void *packet,
uh_sump = udpp + offsetof(struct udphdr, uh_sum); uh_sump = udpp + offsetof(struct udphdr, uh_sum);
memset(uh_sump, 0, sizeof(udp.uh_sum)); memset(uh_sump, 0, sizeof(udp.uh_sum));
/* Checksum psuedo header and then UDP + payload. */ /* Checksum pseudo header and then UDP + payload. */
in_cksum(pip.w, sizeof(pip.w), &csum); in_cksum(pip.w, sizeof(pip.w), &csum);
csum = in_cksum(udpp, ntohs(udp.uh_ulen), &csum); csum = in_cksum(udpp, ntohs(udp.uh_ulen), &csum);
@ -3450,6 +3454,35 @@ dhcp_readbpf(void *arg)
state->bpf_flags &= ~BPF_READING; state->bpf_flags &= ~BPF_READING;
} }
static void
dhcp_recvmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg)
{
struct sockaddr_in *from = (struct sockaddr_in *)msg->msg_name;
struct iovec *iov = &msg->msg_iov[0];
struct interface *ifp;
const struct dhcp_state *state;
ifp = if_findifpfromcmsg(ctx, msg, NULL);
if (ifp == NULL) {
logerr(__func__);
return;
}
state = D_CSTATE(ifp);
if (state == NULL) {
logdebugx("%s: received BOOTP for inactive interface",
ifp->name);
return;
}
if (state->bpf_fd != -1) {
/* Avoid a duplicate read if BPF is open for the interface. */
return;
}
dhcp_handlebootp(ifp, (struct bootp *)iov->iov_base, iov->iov_len,
&from->sin_addr);
}
static void static void
dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp) dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp)
{ {
@ -3460,16 +3493,15 @@ dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp)
.iov_base = buf, .iov_base = buf,
.iov_len = sizeof(buf), .iov_len = sizeof(buf),
}; };
#ifdef IP_PKTINFO #ifdef IP_RECVIF
unsigned char ctl[CMSG_SPACE(sizeof(struct sockaddr_dl))] = { 0 };
#else
unsigned char ctl[CMSG_SPACE(sizeof(struct in_pktinfo))] = { 0 }; unsigned char ctl[CMSG_SPACE(sizeof(struct in_pktinfo))] = { 0 };
char sfrom[INET_ADDRSTRLEN];
#endif #endif
struct msghdr msg = { struct msghdr msg = {
.msg_name = &from, .msg_namelen = sizeof(from), .msg_name = &from, .msg_namelen = sizeof(from),
.msg_iov = &iov, .msg_iovlen = 1, .msg_iov = &iov, .msg_iovlen = 1,
#ifdef IP_PKTINFO
.msg_control = ctl, .msg_controllen = sizeof(ctl), .msg_control = ctl, .msg_controllen = sizeof(ctl),
#endif
}; };
int s; int s;
ssize_t bytes; ssize_t bytes;
@ -3486,31 +3518,8 @@ dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp)
return; return;
} }
#ifdef IP_PKTINFO iov.iov_len = (size_t)bytes;
inet_ntop(AF_INET, &from.sin_addr, sfrom, sizeof(sfrom)); dhcp_recvmsg(ctx, &msg);
if (ifp == NULL) {
ifp = if_findifpfromcmsg(ctx, &msg, NULL);
if (ifp == NULL) {
logerr(__func__);
return;
}
state = D_CSTATE(ifp);
if (state == NULL) {
logdebugx("%s: received BOOTP for inactive interface",
ifp->name);
return;
}
}
if (state->bpf_fd != -1) {
/* Avoid a duplicate read if BPF is open for the interface. */
return;
}
dhcp_handlebootp(ifp, (struct bootp *)(void *)buf, (size_t)bytes,
&from.sin_addr);
#endif
} }
static void static void
@ -3521,16 +3530,24 @@ dhcp_handleudp(void *arg)
dhcp_readudp(ctx, NULL); dhcp_readudp(ctx, NULL);
} }
#ifdef IP_PKTINFO
static void static void
dhcp_handleifudp(void *arg) dhcp_handleifudp(void *arg)
{ {
struct interface *ifp = arg; struct interface *ifp = arg;
dhcp_readudp(ifp->ctx, ifp); dhcp_readudp(ifp->ctx, ifp);
} }
#endif
static int
dhcp_open(struct dhcpcd_ctx *ctx)
{
if (ctx->udp_fd != -1 || (ctx->udp_fd = dhcp_openudp(NULL)) == -1)
return ctx->udp_fd;
eloop_event_add(ctx->eloop, ctx->udp_fd, dhcp_handleudp, ctx);
return ctx->udp_fd;
}
static int static int
dhcp_openbpf(struct interface *ifp) dhcp_openbpf(struct interface *ifp)
@ -3740,16 +3757,13 @@ dhcp_start1(void *arg)
* ICMP port unreachable message back to the DHCP server. * ICMP port unreachable message back to the DHCP server.
* Only do this in master mode so we don't swallow messages * Only do this in master mode so we don't swallow messages
* for dhcpcd running on another interface. */ * for dhcpcd running on another interface. */
if (ctx->udp_fd == -1 && ctx->options & DHCPCD_MASTER) { if (ctx->options & DHCPCD_MASTER) {
ctx->udp_fd = dhcp_openudp(NULL); if (dhcp_open(ctx) == -1) {
if (ctx->udp_fd == -1) {
/* Don't log an error if some other process /* Don't log an error if some other process
* is handling this. */ * is handling this. */
if (errno != EADDRINUSE) if (errno != EADDRINUSE)
logerr("%s: dhcp_openudp", __func__); logerr("%s: dhcp_open", __func__);
} else }
eloop_event_add(ctx->eloop,
ctx->udp_fd, dhcp_handleudp, ctx);
} }
if (dhcp_init(ifp) == -1) { if (dhcp_init(ifp) == -1) {
@ -4008,7 +4022,7 @@ dhcp_handleifa(int cmd, struct ipv4_addr *ia, pid_t pid)
* to drop the lease. */ * to drop the lease. */
dhcp_drop(ifp, "EXPIRE"); dhcp_drop(ifp, "EXPIRE");
dhcp_start1(ifp); dhcp_start1(ifp);
return NULL; return ia;
} }
} }

79
external/bsd/dhcpcd/dist/src/dhcp6.c vendored
View File

@ -3465,23 +3465,10 @@ dhcp6_recvif(struct interface *ifp, const char *sfrom,
} }
static void static void
dhcp6_recv(struct dhcpcd_ctx *ctx, struct ipv6_addr *ia) dhcp6_recvmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg, struct ipv6_addr *ia)
{ {
struct sockaddr_in6 from; struct sockaddr_in6 *from = msg->msg_name;
unsigned char buf[64 * 1024]; /* Maximum UDP message size */ size_t len = msg->msg_iov[0].iov_len;
struct iovec iov = {
.iov_base = buf,
.iov_len = sizeof(buf),
};
unsigned char ctl[CMSG_SPACE(sizeof(struct in6_pktinfo))] = { 0 };
struct msghdr msg = {
.msg_name = &from, .msg_namelen = sizeof(from),
.msg_iov = &iov, .msg_iovlen = 1,
.msg_control = ctl, .msg_controllen = sizeof(ctl),
};
int s;
size_t len;
ssize_t bytes;
char sfrom[INET6_ADDRSTRLEN]; char sfrom[INET6_ADDRSTRLEN];
struct interface *ifp; struct interface *ifp;
struct dhcp6_message *r; struct dhcp6_message *r;
@ -3489,14 +3476,7 @@ dhcp6_recv(struct dhcpcd_ctx *ctx, struct ipv6_addr *ia)
uint8_t *o; uint8_t *o;
uint16_t ol; uint16_t ol;
s = ia != NULL ? ia->dhcp6_fd : ctx->dhcp6_fd; inet_ntop(AF_INET6, &from->sin6_addr, sfrom, sizeof(sfrom));
bytes = recvmsg(s, &msg, 0);
if (bytes == -1) {
logerr(__func__);
return;
}
len = (size_t)bytes;
inet_ntop(AF_INET6, &from.sin6_addr, sfrom, sizeof(sfrom));
if (len < sizeof(struct dhcp6_message)) { if (len < sizeof(struct dhcp6_message)) {
logerrx("DHCPv6 packet too short from %s", sfrom); logerrx("DHCPv6 packet too short from %s", sfrom);
return; return;
@ -3505,14 +3485,14 @@ dhcp6_recv(struct dhcpcd_ctx *ctx, struct ipv6_addr *ia)
if (ia != NULL) if (ia != NULL)
ifp = ia->iface; ifp = ia->iface;
else { else {
ifp = if_findifpfromcmsg(ctx, &msg, NULL); ifp = if_findifpfromcmsg(ctx, msg, NULL);
if (ifp == NULL) { if (ifp == NULL) {
logerr(__func__); logerr(__func__);
return; return;
} }
} }
r = (struct dhcp6_message *)buf; r = (struct dhcp6_message *)msg->msg_iov[0].iov_base;
o = dhcp6_findmoption(r, len, D6_OPTION_CLIENTID, &ol); o = dhcp6_findmoption(r, len, D6_OPTION_CLIENTID, &ol);
if (o == NULL || ol != ctx->duid_len || if (o == NULL || ol != ctx->duid_len ||
memcmp(o, ctx->duid, ol) != 0) memcmp(o, ctx->duid, ol) != 0)
@ -3580,6 +3560,35 @@ dhcp6_recv(struct dhcpcd_ctx *ctx, struct ipv6_addr *ia)
dhcp6_recvif(ifp, sfrom, r, len); dhcp6_recvif(ifp, sfrom, r, len);
} }
static void
dhcp6_recv(struct dhcpcd_ctx *ctx, struct ipv6_addr *ia)
{
struct sockaddr_in6 from;
unsigned char buf[64 * 1024]; /* Maximum UDP message size */
struct iovec iov = {
.iov_base = buf,
.iov_len = sizeof(buf),
};
unsigned char ctl[CMSG_SPACE(sizeof(struct in6_pktinfo))] = { 0 };
struct msghdr msg = {
.msg_name = &from, .msg_namelen = sizeof(from),
.msg_iov = &iov, .msg_iovlen = 1,
.msg_control = ctl, .msg_controllen = sizeof(ctl),
};
int s;
ssize_t bytes;
s = ia != NULL ? ia->dhcp6_fd : ctx->dhcp6_fd;
bytes = recvmsg(s, &msg, 0);
if (bytes == -1) {
logerr(__func__);
return;
}
iov.iov_len = (size_t)bytes;
dhcp6_recvmsg(ctx, &msg, ia);
}
static void static void
dhcp6_recvaddr(void *arg) dhcp6_recvaddr(void *arg)
{ {
@ -3677,6 +3686,18 @@ dhcp6_activateinterfaces(struct interface *ifp)
} }
#endif #endif
static int
dhcp6_open(struct dhcpcd_ctx *ctx)
{
if (ctx->dhcp6_fd != -1 ||
(ctx->dhcp6_fd = dhcp6_listen(ctx, NULL)) == -1)
return ctx->dhcp6_fd;
eloop_event_add(ctx->eloop, ctx->dhcp6_fd, dhcp6_recvctx, ctx);
return ctx->dhcp6_fd;
}
static void static void
dhcp6_start1(void *arg) dhcp6_start1(void *arg)
{ {
@ -3687,11 +3708,9 @@ dhcp6_start1(void *arg)
size_t i; size_t i;
const struct dhcp_compat *dhc; const struct dhcp_compat *dhc;
if (ctx->dhcp6_fd == -1 && ctx->options & DHCPCD_MASTER) { if (ctx->options & DHCPCD_MASTER) {
ctx->dhcp6_fd = dhcp6_listen(ctx, NULL); if (dhcp6_open(ctx) == -1)
if (ctx->dhcp6_fd == -1)
return; return;
eloop_event_add(ctx->eloop, ctx->dhcp6_fd, dhcp6_recvctx, ctx);
} }
state = D6_STATE(ifp); state = D6_STATE(ifp);

32
external/bsd/dhcpcd/dist/src/dhcpcd.c vendored
View File

@ -186,6 +186,12 @@ handle_exit_timeout(void *arg)
ctx = arg; ctx = arg;
logerrx("timed out"); logerrx("timed out");
if (!(ctx->options & DHCPCD_MASTER)) { if (!(ctx->options & DHCPCD_MASTER)) {
struct interface *ifp;
TAILQ_FOREACH(ifp, ctx->ifaces, next) {
if (ifp->active == IF_ACTIVE_USER)
script_runreason(ifp, "STOPPED");
}
eloop_exit(ctx->eloop, EXIT_FAILURE); eloop_exit(ctx->eloop, EXIT_FAILURE);
return; return;
} }
@ -702,6 +708,21 @@ dhcpcd_initstate(struct interface *ifp, unsigned long long options)
dhcpcd_initstate1(ifp, ifp->ctx->argc, ifp->ctx->argv, options); dhcpcd_initstate1(ifp, ifp->ctx->argc, ifp->ctx->argv, options);
} }
static void
dhcpcd_reportssid(struct interface *ifp)
{
char pssid[IF_SSIDLEN * 4];
if (print_string(pssid, sizeof(pssid), OT_ESCSTRING,
ifp->ssid, ifp->ssid_len) == -1)
{
logerr(__func__);
return;
}
loginfox("%s: connected to Access Point `%s'", ifp->name, pssid);
}
void void
dhcpcd_handlecarrier(struct dhcpcd_ctx *ctx, int carrier, unsigned int flags, dhcpcd_handlecarrier(struct dhcpcd_ctx *ctx, int carrier, unsigned int flags,
const char *ifname) const char *ifname)
@ -773,6 +794,7 @@ dhcpcd_handlecarrier(struct dhcpcd_ctx *ctx, int carrier, unsigned int flags,
if (ifp->ssid_len != olen || if (ifp->ssid_len != olen ||
memcmp(ifp->ssid, ossid, ifp->ssid_len)) memcmp(ifp->ssid, ossid, ifp->ssid_len))
{ {
dhcpcd_reportssid(ifp);
#ifdef NOCARRIER_PRESERVE_IP #ifdef NOCARRIER_PRESERVE_IP
dhcpcd_drop(ifp, 0); dhcpcd_drop(ifp, 0);
#endif #endif
@ -970,7 +992,8 @@ run_preinit(struct interface *ifp)
return; return;
script_runreason(ifp, "PREINIT"); script_runreason(ifp, "PREINIT");
if (ifp->wireless)
dhcpcd_reportssid(ifp);
if (ifp->options->options & DHCPCD_LINK && ifp->carrier != LINK_UNKNOWN) if (ifp->options->options & DHCPCD_LINK && ifp->carrier != LINK_UNKNOWN)
script_runreason(ifp, script_runreason(ifp,
ifp->carrier == LINK_UP ? "CARRIER" : "NOCARRIER"); ifp->carrier == LINK_UP ? "CARRIER" : "NOCARRIER");
@ -1989,6 +2012,12 @@ printpidfile:
ctx.options & DHCPCD_IPV4 ? " [ip4]" : "", ctx.options & DHCPCD_IPV4 ? " [ip4]" : "",
ctx.options & DHCPCD_IPV6 ? " [ip6]" : ""); ctx.options & DHCPCD_IPV6 ? " [ip6]" : "");
#ifdef BSD
/* Disable the kernel RTADV sysctl as early as possible. */
if (ctx.options & DHCPCD_IPV6 && ctx.options & DHCPCD_IPV6RS)
if_disable_rtadv();
#endif
if (if_opensockets(&ctx) == -1) { if (if_opensockets(&ctx) == -1) {
logerr("%s: if_opensockets", __func__); logerr("%s: if_opensockets", __func__);
goto exit_failure; goto exit_failure;
@ -2127,6 +2156,7 @@ exit1:
if_free(ifp); if_free(ifp);
} }
free(ctx.ifaces); free(ctx.ifaces);
ctx.ifaces = NULL;
} }
free_options(&ctx, ifo); free_options(&ctx, ifo);
#ifdef HAVE_OPEN_MEMSTREAM #ifdef HAVE_OPEN_MEMSTREAM

27
external/bsd/dhcpcd/dist/src/eloop.c vendored
View File

@ -830,7 +830,8 @@ eloop_new(void)
return eloop; return eloop;
} }
void eloop_free(struct eloop *eloop) void
eloop_clear(struct eloop *eloop)
{ {
struct eloop_event *e; struct eloop_event *e;
struct eloop_timeout *t; struct eloop_timeout *t;
@ -839,6 +840,12 @@ void eloop_free(struct eloop *eloop)
return; return;
free(eloop->event_fds); free(eloop->event_fds);
eloop->event_fds = NULL;
eloop->events_len = 0;
eloop->events_maxfd = -1;
eloop->signals = NULL;
eloop->signals_len = 0;
while ((e = TAILQ_FIRST(&eloop->events))) { while ((e = TAILQ_FIRST(&eloop->events))) {
TAILQ_REMOVE(&eloop->events, e, next); TAILQ_REMOVE(&eloop->events, e, next);
free(e); free(e);
@ -855,11 +862,23 @@ void eloop_free(struct eloop *eloop)
TAILQ_REMOVE(&eloop->free_timeouts, t, next); TAILQ_REMOVE(&eloop->free_timeouts, t, next);
free(t); free(t);
} }
#if defined(HAVE_KQUEUE) || defined(HAVE_EPOLL)
close(eloop->poll_fd); #if defined(HAVE_POLL)
#elif defined(HAVE_POLL)
free(eloop->fds); free(eloop->fds);
eloop->fds = NULL;
eloop->fds_len = 0;
#endif #endif
}
void
eloop_free(struct eloop *eloop)
{
#if defined(HAVE_KQUEUE) || defined(HAVE_EPOLL)
if (eloop != NULL)
close(eloop->poll_fd);
#endif
eloop_clear(eloop);
free(eloop); free(eloop);
} }

1
external/bsd/dhcpcd/dist/src/eloop.h vendored
View File

@ -105,6 +105,7 @@ int eloop_signal_mask(struct eloop *, sigset_t *oldset);
struct eloop * eloop_new(void); struct eloop * eloop_new(void);
int eloop_requeue(struct eloop *); int eloop_requeue(struct eloop *);
void eloop_clear(struct eloop *);
void eloop_free(struct eloop *); void eloop_free(struct eloop *);
void eloop_exit(struct eloop *, int); void eloop_exit(struct eloop *, int);
int eloop_start(struct eloop *, sigset_t *); int eloop_start(struct eloop *, sigset_t *);

71
external/bsd/dhcpcd/dist/src/if-bsd.c vendored
View File

@ -1130,6 +1130,10 @@ if_ifinfo(struct dhcpcd_ctx *ctx, const struct if_msghdr *ifm)
case LINK_STATE_UNKNOWN: case LINK_STATE_UNKNOWN:
link_state = LINK_UNKNOWN; link_state = LINK_UNKNOWN;
break; break;
#ifdef LINK_STATE_FULL_DUPLEX
case LINK_STATE_HALF_DUPLEX: /* FALLTHROUGH */
case LINK_STATE_FULL_DUPLEX: /* FALLTHROUGH */
#endif
case LINK_STATE_UP: case LINK_STATE_UP:
link_state = LINK_UP; link_state = LINK_UP;
break; break;
@ -1484,6 +1488,42 @@ inet6_sysctl(int code, int val, int action)
} }
#endif #endif
int
if_applyra(const struct ra *rap)
{
#ifdef SIOCSIFINFO_IN6
struct in6_ndireq ndi = { .ndi.chlim = 0 };
struct priv *priv = rap->iface->ctx->priv;
int error;
strlcpy(ndi.ifname, rap->iface->name, sizeof(ndi.ifname));
if (ioctl(priv->pf_inet6_fd, SIOCGIFINFO_IN6, &ndi) == -1)
return -1;
ndi.ndi.linkmtu = rap->mtu;
ndi.ndi.chlim = rap->hoplimit;
ndi.ndi.retrans = rap->retrans;
ndi.ndi.basereachable = rap->reachable;
error = ioctl(priv->pf_inet6_fd, SIOCSIFINFO_IN6, &ndi);
if (error == -1 && errno == EINVAL) {
/*
* Very likely that this is caused by a dodgy MTU
* setting specific to the interface.
* Let's set it to "unspecified" and try again.
* Doesn't really matter as we fix the MTU against the
* routes we add as not all OS support SIOCSIFINFO_IN6.
*/
ndi.ndi.linkmtu = 0;
error = ioctl(priv->pf_inet6_fd, SIOCSIFINFO_IN6, &ndi);
}
return error;
#else
#warning OS does not allow setting of RA bits hoplimit, retrans or reachable
UNUSED(rap);
return 0;
#endif
}
#ifdef IPV6_MANAGETEMPADDR #ifdef IPV6_MANAGETEMPADDR
#ifndef IPV6CTL_TEMPVLTIME #ifndef IPV6CTL_TEMPVLTIME
#define get_inet6_sysctlbyname(code) inet6_sysctlbyname(code, 0, 0) #define get_inet6_sysctlbyname(code) inet6_sysctlbyname(code, 0, 0)
@ -1619,6 +1659,22 @@ set_ifxflags(int s, const struct interface *ifp)
#define ND6_NDI_FLAGS #define ND6_NDI_FLAGS
#endif #endif
void
if_disable_rtadv(void)
{
#if defined(IPV6CTL_ACCEPT_RTADV) && !defined(ND6_IFF_ACCEPT_RTADV)
int ra = get_inet6_sysctl(IPV6CTL_ACCEPT_RTADV);
if (ra == -1) {
if (errno != ENOENT)
logerr("IPV6CTL_ACCEPT_RTADV");
else if (ra != 0)
if (set_inet6_sysctl(IPV6CTL_ACCEPT_RTADV, 0) == -1)
logerr("IPV6CTL_ACCEPT_RTADV");
}
#endif
}
void void
if_setup_inet6(const struct interface *ifp) if_setup_inet6(const struct interface *ifp)
{ {
@ -1690,21 +1746,6 @@ if_setup_inet6(const struct interface *ifp)
logerr("%s: set_ifxflags", ifp->name); logerr("%s: set_ifxflags", ifp->name);
#endif #endif
#if defined(IPV6CTL_ACCEPT_RTADV) && !defined(ND6_IFF_ACCEPT_RTADV)
/* If we cannot control ra per interface, disable it globally. */
if (ifp->options->options & DHCPCD_IPV6RS) {
int ra = get_inet6_sysctl(IPV6CTL_ACCEPT_RTADV);
if (ra == -1) {
if (errno != ENOENT)
logerr("IPV6CTL_ACCEPT_RTADV");
else if (ra != 0)
if (set_inet6_sysctl(IPV6CTL_ACCEPT_RTADV, 0) == -1)
logerr("IPV6CTL_ACCEPT_RTADV");
}
}
#endif
#if defined(IPV6CTL_ACCEPT_RTADV) || defined(ND6_IFF_ACCEPT_RTADV) #if defined(IPV6CTL_ACCEPT_RTADV) || defined(ND6_IFF_ACCEPT_RTADV)
/* Flush the kernel knowledge of advertised routers /* Flush the kernel knowledge of advertised routers
* and prefixes so the kernel does not expire prefixes * and prefixes so the kernel does not expire prefixes

20
external/bsd/dhcpcd/dist/src/if.c vendored
View File

@ -740,9 +740,13 @@ if_findifpfromcmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg, int *hoplimit)
struct cmsghdr *cm; struct cmsghdr *cm;
unsigned int ifindex = 0; unsigned int ifindex = 0;
struct interface *ifp; struct interface *ifp;
#if defined(INET) && defined(IP_PKTINFO) #ifdef INET
#ifdef IP_RECVIF
struct sockaddr_dl sdl;
#else
struct in_pktinfo ipi; struct in_pktinfo ipi;
#endif #endif
#endif
#ifdef INET6 #ifdef INET6
struct in6_pktinfo ipi6; struct in6_pktinfo ipi6;
#else #else
@ -753,15 +757,27 @@ if_findifpfromcmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg, int *hoplimit)
cm; cm;
cm = (struct cmsghdr *)CMSG_NXTHDR(msg, cm)) cm = (struct cmsghdr *)CMSG_NXTHDR(msg, cm))
{ {
#if defined(INET) && defined(IP_PKTINFO) #ifdef INET
if (cm->cmsg_level == IPPROTO_IP) { if (cm->cmsg_level == IPPROTO_IP) {
switch(cm->cmsg_type) { switch(cm->cmsg_type) {
#ifdef IP_RECVIF
case IP_RECVIF:
if (cm->cmsg_len <
offsetof(struct sockaddr_dl, sdl_index) +
sizeof(sdl.sdl_index))
continue;
memcpy(&sdl, CMSG_DATA(cm),
MIN(sizeof(sdl), cm->cmsg_len));
ifindex = sdl.sdl_index;
break;
#else
case IP_PKTINFO: case IP_PKTINFO:
if (cm->cmsg_len != CMSG_LEN(sizeof(ipi))) if (cm->cmsg_len != CMSG_LEN(sizeof(ipi)))
continue; continue;
memcpy(&ipi, CMSG_DATA(cm), sizeof(ipi)); memcpy(&ipi, CMSG_DATA(cm), sizeof(ipi));
ifindex = (unsigned int)ipi.ipi_ifindex; ifindex = (unsigned int)ipi.ipi_ifindex;
break; break;
#endif
} }
} }
#endif #endif

3
external/bsd/dhcpcd/dist/src/if.h vendored
View File

@ -65,6 +65,7 @@
#include "dhcpcd.h" #include "dhcpcd.h"
#include "ipv4.h" #include "ipv4.h"
#include "ipv6.h" #include "ipv6.h"
#include "ipv6nd.h"
#include "route.h" #include "route.h"
#define EUI64_ADDR_LEN 8 #define EUI64_ADDR_LEN 8
@ -195,6 +196,7 @@ int if_addrflags(const struct interface *, const struct in_addr *,
#endif #endif
#ifdef INET6 #ifdef INET6
void if_disable_rtadv(void);
void if_setup_inet6(const struct interface *); void if_setup_inet6(const struct interface *);
#ifdef IPV6_MANAGETEMPADDR #ifdef IPV6_MANAGETEMPADDR
int ip6_use_tempaddr(const char *ifname); int ip6_use_tempaddr(const char *ifname);
@ -205,6 +207,7 @@ int ip6_temp_valid_lifetime(const char *ifname);
#endif #endif
int ip6_forwarding(const char *ifname); int ip6_forwarding(const char *ifname);
int if_applyra(const struct ra *);
int if_address6(unsigned char, const struct ipv6_addr *); int if_address6(unsigned char, const struct ipv6_addr *);
int if_addrflags6(const struct interface *, const struct in6_addr *, int if_addrflags6(const struct interface *, const struct in6_addr *,
const char *); const char *);

25
external/bsd/dhcpcd/dist/src/ipv4.c vendored
View File

@ -654,7 +654,7 @@ ipv4_addaddr(struct interface *ifp, const struct in_addr *addr,
#endif #endif
ia->flags = IPV4_AF_NEW; ia->flags = IPV4_AF_NEW;
} else } else
ia->flags |= ~IPV4_AF_NEW; ia->flags &= ~IPV4_AF_NEW;
ia->mask = *mask; ia->mask = *mask;
ia->brd = *bcast; ia->brd = *bcast;
@ -687,7 +687,8 @@ ipv4_addaddr(struct interface *ifp, const struct in_addr *addr,
if (errno != EEXIST) if (errno != EEXIST)
logerr("%s: if_addaddress", logerr("%s: if_addaddress",
__func__); __func__);
free(ia); if (ia->flags & IPV4_AF_NEW)
free(ia);
return NULL; return NULL;
} }
@ -941,7 +942,7 @@ ipv4_handleifa(struct dhcpcd_ctx *ctx,
#endif #endif
} }
if (cmd == RTM_DELADDR && ia != NULL) if (cmd == RTM_DELADDR)
free(ia); free(ia);
} }
@ -951,15 +952,13 @@ ipv4_free(struct interface *ifp)
struct ipv4_state *state; struct ipv4_state *state;
struct ipv4_addr *ia; struct ipv4_addr *ia;
if (ifp) { if (ifp == NULL || (state = IPV4_STATE(ifp)) == NULL)
state = IPV4_STATE(ifp); return;
if (state) {
while ((ia = TAILQ_FIRST(&state->addrs))) { while ((ia = TAILQ_FIRST(&state->addrs))) {
TAILQ_REMOVE(&state->addrs, ia, next); TAILQ_REMOVE(&state->addrs, ia, next);
free(ia); free(ia);
}
free(state->buffer);
free(state);
}
} }
free(state->buffer);
free(state);
} }

323
external/bsd/dhcpcd/dist/src/ipv6nd.c vendored
View File

@ -196,36 +196,41 @@ ipv6nd_printoptions(const struct dhcpcd_ctx *ctx,
static int static int
ipv6nd_open0(void) ipv6nd_open0(void)
{ {
int s, on; int fd, on;
struct icmp6_filter filt; struct icmp6_filter filt;
#define SOCK_FLAGS SOCK_CLOEXEC | SOCK_NONBLOCK #define SOCK_FLAGS SOCK_CLOEXEC | SOCK_NONBLOCK
s = xsocket(PF_INET6, SOCK_RAW | SOCK_FLAGS, IPPROTO_ICMPV6); fd = xsocket(PF_INET6, SOCK_RAW | SOCK_FLAGS, IPPROTO_ICMPV6);
#undef SOCK_FLAGS #undef SOCK_FLAGS
if (s == -1) if (fd == -1)
return -1; return -1;
/* RFC4861 4.1 */ /* RFC4861 4.1 */
on = 255; on = 255;
if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
&on, sizeof(on)) == -1) &on, sizeof(on)) == -1)
goto eexit; goto eexit;
on = 1; on = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
&on, sizeof(on)) == -1)
goto eexit;
on = 1;
if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
&on, sizeof(on)) == -1) &on, sizeof(on)) == -1)
goto eexit; goto eexit;
ICMP6_FILTER_SETBLOCKALL(&filt); ICMP6_FILTER_SETBLOCKALL(&filt);
ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filt); ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filt);
if (setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER, if (setsockopt(fd, IPPROTO_ICMPV6, ICMP6_FILTER,
&filt, sizeof(filt)) == -1) &filt, sizeof(filt)) == -1)
goto eexit; goto eexit;
return s; return fd;
eexit: eexit:
close(s); close(fd);
return -1; return -1;
} }
@ -233,7 +238,7 @@ eexit:
static int static int
ipv6nd_open(struct interface *ifp) ipv6nd_open(struct interface *ifp)
{ {
int s; int fd;
struct ipv6_mreq mreq = { struct ipv6_mreq mreq = {
.ipv6mr_multiaddr = IN6ADDR_LINKLOCAL_ALLNODES_INIT, .ipv6mr_multiaddr = IN6ADDR_LINKLOCAL_ALLNODES_INIT,
.ipv6mr_interface = ifp->index .ipv6mr_interface = ifp->index
@ -244,52 +249,44 @@ ipv6nd_open(struct interface *ifp)
if (state->nd_fd != -1) if (state->nd_fd != -1)
return state->nd_fd; return state->nd_fd;
s = ipv6nd_open0(); fd = ipv6nd_open0();
if (s == -1) if (fd == -1)
return -1; return -1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_BOUND_IF, if (setsockopt(fd, IPPROTO_IPV6, IPV6_BOUND_IF,
&ifindex, sizeof(ifindex)) == -1) &ifindex, sizeof(ifindex)) == -1)
{ {
close(s); close(fd);
return -1; return -1;
} }
if (setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP, if (setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP,
&mreq, sizeof(mreq)) == -1) &mreq, sizeof(mreq)) == -1)
{ {
close(s); close(fd);
return -1; return -1;
} }
state->nd_fd = s; state->nd_fd = fd;
eloop_event_add(ifp->ctx->eloop, s, ipv6nd_handledata, ifp); eloop_event_add(ifp->ctx->eloop, fd, ipv6nd_handledata, ifp);
return s; return fd;
} }
#else #else
static int static int
ipv6nd_open(struct dhcpcd_ctx *ctx) ipv6nd_open(struct dhcpcd_ctx *ctx)
{ {
int s, on; int fd;
if (ctx->nd_fd != -1) if (ctx->nd_fd != -1)
return ctx->nd_fd; return ctx->nd_fd;
s = ipv6nd_open0(); fd = ipv6nd_open0();
if (s == -1) if (fd == -1)
return -1; return -1;
on = 1; ctx->nd_fd = fd;
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO, eloop_event_add(ctx->eloop, fd, ipv6nd_handledata, ctx);
&on, sizeof(on)) == -1) return fd;
{
close(s);
return -1;
}
ctx->nd_fd = s;
eloop_event_add(ctx->eloop, s, ipv6nd_handledata, ctx);
return s;
} }
#endif #endif
@ -559,6 +556,76 @@ ipv6nd_startexpire(struct interface *ifp)
ipv6nd_expire, ifp); ipv6nd_expire, ifp);
} }
static int
ipv6nd_rtpref(struct ra *rap)
{
switch (rap->flags & ND_RA_FLAG_RTPREF_MASK) {
case ND_RA_FLAG_RTPREF_HIGH:
return RTPREF_HIGH;
case ND_RA_FLAG_RTPREF_MEDIUM:
case ND_RA_FLAG_RTPREF_RSV:
return RTPREF_MEDIUM;
case ND_RA_FLAG_RTPREF_LOW:
return RTPREF_LOW;
default:
logerrx("%s: impossible RA flag %x", __func__, rap->flags);
return RTPREF_INVALID;
}
/* NOTREACHED */
}
static void
ipv6nd_sortrouters(struct dhcpcd_ctx *ctx)
{
struct ra_head sorted_routers = TAILQ_HEAD_INITIALIZER(sorted_routers);
struct ra *ra1, *ra2;
while ((ra1 = TAILQ_FIRST(ctx->ra_routers)) != NULL) {
TAILQ_REMOVE(ctx->ra_routers, ra1, next);
TAILQ_FOREACH(ra2, &sorted_routers, next) {
if (ra1->iface->metric < ra2->iface->metric)
continue;
if (ra1->expired && !ra2->expired)
continue;
if (ra1->lifetime == 0 && ra2->lifetime != 0)
continue;
if (!ra1->isreachable && ra2->reachable)
continue;
if (ipv6nd_rtpref(ra1) < ipv6nd_rtpref(ra2))
continue;
/* All things being equal, prefer older routers. */
if (timespeccmp(&ra1->acquired, &ra2->acquired, >=))
continue;
TAILQ_INSERT_BEFORE(ra2, ra1, next);
break;
}
if (ra2 == NULL)
TAILQ_INSERT_TAIL(&sorted_routers, ra1, next);
}
TAILQ_CONCAT(ctx->ra_routers, &sorted_routers, next);
}
static void
ipv6nd_applyra(struct dhcpcd_ctx *ctx, struct interface *ifp)
{
struct ra *rap;
struct rs_state *state = RS_STATE(ifp);
TAILQ_FOREACH(rap, ctx->ra_routers, next) {
if (rap->iface == ifp)
break;
}
if (rap == NULL)
return;
state->retrans = rap->retrans;
if (if_applyra(rap) == -1)
logerr(__func__);
}
/* /*
* Neighbour reachability. * Neighbour reachability.
* *
@ -585,23 +652,20 @@ ipv6nd_neighbour(struct dhcpcd_ctx *ctx, struct in6_addr *addr, bool reachable)
break; break;
} }
if (rap == NULL || rap->expired) if (rap == NULL || rap->expired || rap->reachable == reachable)
return; return;
if (reachable) { rap->isreachable = reachable;
if (rap->isreachable) loginfox("%s: %s is %s", rap->iface->name, rap->sfrom,
return; reachable ? "reachable again" : "unreachable");
loginfox("%s: %s is reachable again",
rap->iface->name, rap->sfrom); /* See if we can install a reachable default router. */
rap->isreachable = true; ipv6nd_sortrouters(ctx);
ipv6nd_applyra(ctx, rap->iface);
rt_build(ctx, AF_INET6);
if (reachable)
return; return;
} else {
if (!rap->isreachable)
return;
logwarnx("%s: %s is unreachable",
rap->iface->name, rap->sfrom);
rap->isreachable = false;
}
/* If we have no reachable default routers, try and solicit one. */ /* If we have no reachable default routers, try and solicit one. */
TAILQ_FOREACH(rapr, ctx->ra_routers, next) { TAILQ_FOREACH(rapr, ctx->ra_routers, next) {
@ -722,42 +786,6 @@ ipv6nd_free(struct interface *ifp)
return n; return n;
} }
static int
rtpref(struct ra *rap)
{
switch (rap->flags & ND_RA_FLAG_RTPREF_MASK) {
case ND_RA_FLAG_RTPREF_HIGH:
return (RTPREF_HIGH);
case ND_RA_FLAG_RTPREF_MEDIUM:
case ND_RA_FLAG_RTPREF_RSV:
return (RTPREF_MEDIUM);
case ND_RA_FLAG_RTPREF_LOW:
return (RTPREF_LOW);
default:
logerrx("rtpref: impossible RA flag %x", rap->flags);
return (RTPREF_INVALID);
}
/* NOTREACHED */
}
static void
add_router(struct dhcpcd_ctx *ctx, struct ra *router)
{
struct ra *rap;
TAILQ_FOREACH(rap, ctx->ra_routers, next) {
if (router->iface->metric < rap->iface->metric ||
(router->iface->metric == rap->iface->metric &&
rtpref(router) > rtpref(rap)))
{
TAILQ_INSERT_BEFORE(rap, router, next);
return;
}
}
TAILQ_INSERT_TAIL(ctx->ra_routers, router, next);
}
static int static int
ipv6nd_scriptrun(struct ra *rap) ipv6nd_scriptrun(struct ra *rap)
{ {
@ -965,6 +993,7 @@ ipv6nd_handlera(struct dhcpcd_ctx *ctx,
struct dhcp_opt *dho; struct dhcp_opt *dho;
bool new_rap, new_data, has_address; bool new_rap, new_data, has_address;
uint32_t old_lifetime; uint32_t old_lifetime;
int ifmtu;
__printflike(1, 2) void (*logfunc)(const char *, ...); __printflike(1, 2) void (*logfunc)(const char *, ...);
#ifdef IPV6_MANAGETEMPADDR #ifdef IPV6_MANAGETEMPADDR
uint8_t new_ap; uint8_t new_ap;
@ -1074,20 +1103,25 @@ ipv6nd_handlera(struct dhcpcd_ctx *ctx,
if (!new_rap && rap->lifetime == 0 && old_lifetime != 0) if (!new_rap && rap->lifetime == 0 && old_lifetime != 0)
logwarnx("%s: %s: no longer a default router", logwarnx("%s: %s: no longer a default router",
ifp->name, rap->sfrom); ifp->name, rap->sfrom);
if (nd_ra->nd_ra_reachable) { if (nd_ra->nd_ra_curhoplimit != 0)
rap->hoplimit = nd_ra->nd_ra_curhoplimit;
else
rap->hoplimit = IPV6_DEFHLIM;
if (nd_ra->nd_ra_reachable != 0) {
rap->reachable = ntohl(nd_ra->nd_ra_reachable); rap->reachable = ntohl(nd_ra->nd_ra_reachable);
if (rap->reachable > MAX_REACHABLE_TIME) if (rap->reachable > MAX_REACHABLE_TIME)
rap->reachable = 0; rap->reachable = 0;
} } else
if (nd_ra->nd_ra_retransmit) { rap->reachable = REACHABLE_TIME;
struct rs_state *state = RS_STATE(ifp); if (nd_ra->nd_ra_retransmit != 0)
rap->retrans = ntohl(nd_ra->nd_ra_retransmit);
state->retrans = rap->retrans = ntohl(nd_ra->nd_ra_retransmit); else
} rap->retrans = RETRANS_TIMER;
rap->expired = false; rap->expired = false;
rap->hasdns = false; rap->hasdns = false;
rap->isreachable = true; rap->isreachable = true;
has_address = false; has_address = false;
rap->mtu = 0;
#ifdef IPV6_AF_TEMPORARY #ifdef IPV6_AF_TEMPORARY
ipv6_markaddrsstale(ifp, IPV6_AF_TEMPORARY); ipv6_markaddrsstale(ifp, IPV6_AF_TEMPORARY);
@ -1245,22 +1279,30 @@ ipv6nd_handlera(struct dhcpcd_ctx *ctx,
case ND_OPT_MTU: case ND_OPT_MTU:
if (len < sizeof(mtu)) { if (len < sizeof(mtu)) {
logerrx("%s: short MTU option", ifp->name); logfunc("%s: short MTU option", ifp->name);
break; break;
} }
memcpy(&mtu, p, sizeof(mtu)); memcpy(&mtu, p, sizeof(mtu));
mtu.nd_opt_mtu_mtu = ntohl(mtu.nd_opt_mtu_mtu); mtu.nd_opt_mtu_mtu = ntohl(mtu.nd_opt_mtu_mtu);
if (mtu.nd_opt_mtu_mtu < IPV6_MMTU) { if (mtu.nd_opt_mtu_mtu < IPV6_MMTU) {
logerrx("%s: invalid MTU %d", logfunc("%s: invalid MTU %d",
ifp->name, mtu.nd_opt_mtu_mtu); ifp->name, mtu.nd_opt_mtu_mtu);
break; break;
} }
rap->mtu = mtu.nd_opt_mtu_mtu; ifmtu = if_getmtu(ifp);
if (ifmtu == -1)
logerr("if_getmtu");
else if (mtu.nd_opt_mtu_mtu > (uint32_t)ifmtu) {
logfunc("%s: advertised MTU %d"
" is greater than link MTU %d",
ifp->name, mtu.nd_opt_mtu_mtu, ifmtu);
rap->mtu = (uint32_t)ifmtu;
} else
rap->mtu = mtu.nd_opt_mtu_mtu;
break; break;
case ND_OPT_RDNSS: case ND_OPT_RDNSS:
if (len < sizeof(rdnss)) { if (len < sizeof(rdnss)) {
logerrx("%s: short RDNSS option", ifp->name); logfunc("%s: short RDNSS option", ifp->name);
break; break;
} }
memcpy(&rdnss, p, sizeof(rdnss)); memcpy(&rdnss, p, sizeof(rdnss));
@ -1295,12 +1337,15 @@ ipv6nd_handlera(struct dhcpcd_ctx *ctx,
ifp->name); ifp->name);
if (new_rap) if (new_rap)
add_router(ifp->ctx, rap); TAILQ_INSERT_TAIL(ctx->ra_routers, rap, next);
if (new_data)
ipv6nd_sortrouters(ifp->ctx);
if (ifp->ctx->options & DHCPCD_TEST) { if (ifp->ctx->options & DHCPCD_TEST) {
script_runreason(ifp, "TEST"); script_runreason(ifp, "TEST");
goto handle_flag; goto handle_flag;
} }
ipv6nd_applyra(ifp->ctx, ifp);
ipv6_addaddrs(&rap->addrs); ipv6_addaddrs(&rap->addrs);
#ifdef IPV6_MANAGETEMPADDR #ifdef IPV6_MANAGETEMPADDR
ipv6_addtempaddrs(ifp, &rap->acquired); ipv6_addtempaddrs(ifp, &rap->acquired);
@ -1718,11 +1763,52 @@ ipv6nd_drop(struct interface *ifp)
} }
} }
static void
ipv6nd_recvmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg)
{
struct sockaddr_in6 *from = (struct sockaddr_in6 *)msg->msg_name;
char sfrom[INET6_ADDRSTRLEN];
int hoplimit = 0;
struct icmp6_hdr *icp;
struct interface *ifp;
size_t len = msg->msg_iov[0].iov_len;
inet_ntop(AF_INET6, &from->sin6_addr, sfrom, sizeof(sfrom));
if ((size_t)len < sizeof(struct icmp6_hdr)) {
logerrx("IPv6 ICMP packet too short from %s", sfrom);
return;
}
ifp = if_findifpfromcmsg(ctx, msg, &hoplimit);
if (ifp == NULL) {
logerr(__func__);
return;
}
/* Don't do anything if the user hasn't configured it. */
if (ifp->active != IF_ACTIVE_USER ||
!(ifp->options->options & DHCPCD_IPV6))
return;
icp = (struct icmp6_hdr *)msg->msg_iov[0].iov_base;
if (icp->icmp6_code == 0) {
switch(icp->icmp6_type) {
case ND_ROUTER_ADVERT:
ipv6nd_handlera(ctx, from, sfrom,
ifp, icp, (size_t)len, hoplimit);
return;
}
}
logerrx("invalid IPv6 type %d or code %d from %s",
icp->icmp6_type, icp->icmp6_code, sfrom);
}
static void static void
ipv6nd_handledata(void *arg) ipv6nd_handledata(void *arg)
{ {
struct dhcpcd_ctx *ctx; struct dhcpcd_ctx *ctx;
int s; int fd;
struct sockaddr_in6 from; struct sockaddr_in6 from;
unsigned char buf[64 * 1024]; /* Maximum ICMPv6 size */ unsigned char buf[64 * 1024]; /* Maximum ICMPv6 size */
struct iovec iov = { struct iovec iov = {
@ -1736,60 +1822,27 @@ ipv6nd_handledata(void *arg)
.msg_control = ctl, .msg_controllen = sizeof(ctl), .msg_control = ctl, .msg_controllen = sizeof(ctl),
}; };
ssize_t len; ssize_t len;
char sfrom[INET6_ADDRSTRLEN];
int hoplimit = 0;
struct icmp6_hdr *icp;
struct interface *ifp;
#ifdef __sun #ifdef __sun
struct interface *ifp;
struct rs_state *state; struct rs_state *state;
ifp = arg; ifp = arg;
state = RS_STATE(ifp); state = RS_STATE(ifp);
ctx = ifp->ctx; ctx = ifp->ctx;
s = state->nd_fd; fd = state->nd_fd;
#else #else
ctx = arg; ctx = arg;
s = ctx->nd_fd; fd = ctx->nd_fd;
#endif #endif
len = recvmsg(s, &msg, 0); len = recvmsg(fd, &msg, 0);
if (len == -1) { if (len == -1) {
logerr(__func__); logerr(__func__);
return; return;
} }
inet_ntop(AF_INET6, &from.sin6_addr, sfrom, sizeof(sfrom));
if ((size_t)len < sizeof(struct icmp6_hdr)) {
logerrx("IPv6 ICMP packet too short from %s", sfrom);
return;
}
#ifdef __sun iov.iov_len = (size_t)len;
if_findifpfromcmsg(ctx, &msg, &hoplimit); ipv6nd_recvmsg(ctx, &msg);
#else
ifp = if_findifpfromcmsg(ctx, &msg, &hoplimit);
if (ifp == NULL) {
logerr(__func__);
return;
}
#endif
/* Don't do anything if the user hasn't configured it. */
if (ifp->active != IF_ACTIVE_USER ||
!(ifp->options->options & DHCPCD_IPV6))
return;
icp = (struct icmp6_hdr *)buf;
if (icp->icmp6_code == 0) {
switch(icp->icmp6_type) {
case ND_ROUTER_ADVERT:
ipv6nd_handlera(ctx, &from, sfrom,
ifp, icp, (size_t)len, hoplimit);
return;
}
}
logerrx("invalid IPv6 type %d or code %d from %s",
icp->icmp6_type, icp->icmp6_code, sfrom);
} }
static void static void

5
external/bsd/dhcpcd/dist/src/ipv6nd.h vendored
View File

@ -50,6 +50,7 @@ struct ra {
uint32_t reachable; uint32_t reachable;
uint32_t retrans; uint32_t retrans;
uint32_t mtu; uint32_t mtu;
uint8_t hoplimit;
struct ipv6_addrhead addrs; struct ipv6_addrhead addrs;
bool hasdns; bool hasdns;
bool expired; bool expired;
@ -78,6 +79,10 @@ struct rs_state {
#define RTR_SOLICITATION_INTERVAL 4 /* seconds */ #define RTR_SOLICITATION_INTERVAL 4 /* seconds */
#define MAX_RTR_SOLICITATIONS 3 /* times */ #define MAX_RTR_SOLICITATIONS 3 /* times */
#define MAX_NEIGHBOR_ADVERTISEMENT 3 /* 3 transmissions */ #define MAX_NEIGHBOR_ADVERTISEMENT 3 /* 3 transmissions */
#ifndef IPV6_DEFHLIM
#define IPV6_DEFHLIM 64
#endif
#endif #endif
/* On carrier up, expire known routers after RTR_CARRIER_EXPIRE seconds. */ /* On carrier up, expire known routers after RTR_CARRIER_EXPIRE seconds. */

87
external/bsd/dhcpcd/dist/src/script.c vendored
View File

@ -86,9 +86,9 @@ if_printoptions(void)
} }
static int static int
exec_script(const struct dhcpcd_ctx *ctx, char *const *argv, char *const *env) script_exec(const struct dhcpcd_ctx *ctx, char *const *argv, char *const *env)
{ {
pid_t pid; pid_t pid = 0;
posix_spawnattr_t attr; posix_spawnattr_t attr;
int r; int r;
#ifdef USE_SIGNALS #ifdef USE_SIGNALS
@ -173,14 +173,55 @@ efprintf(FILE *fp, const char *fmt, ...)
return r; return r;
} }
static char **
script_buftoenv(struct dhcpcd_ctx *ctx, char *buf, size_t len)
{
char **env, **envp, *bufp, *endp;
size_t nenv;
/* Count the terminated env strings.
* Assert that the terminations are correct. */
nenv = 0;
endp = buf + len;
for (bufp = buf; bufp < endp; bufp++) {
if (*bufp == '\0') {
#ifndef NDEBUG
if (bufp + 1 < endp)
assert(*(bufp + 1) != '\0');
#endif
nenv++;
}
}
assert(*(bufp - 1) == '\0');
if (ctx->script_envlen < nenv) {
env = reallocarray(ctx->script_env, nenv + 1, sizeof(*env));
if (env == NULL)
return NULL;
ctx->script_env = env;
ctx->script_envlen = nenv;
}
bufp = buf;
envp = ctx->script_env;
*envp++ = bufp++;
endp--; /* Avoid setting the last \0 to an invalid pointer */
for (; bufp < endp; bufp++) {
if (*bufp == '\0')
*envp++ = bufp + 1;
}
*envp = NULL;
return ctx->script_env;
}
static long static long
make_env(const struct interface *ifp, const char *reason) make_env(const struct interface *ifp, const char *reason)
{ {
struct dhcpcd_ctx *ctx = ifp->ctx; struct dhcpcd_ctx *ctx = ifp->ctx;
FILE *fp; FILE *fp;
char **env, **envp, *bufp, *endp, *path;
size_t nenv;
long buf_pos, i; long buf_pos, i;
char *path;
int protocol = PROTO_LINK; int protocol = PROTO_LINK;
const struct if_options *ifo = ifp->options; const struct if_options *ifo = ifp->options;
const struct interface *ifp2; const struct interface *ifp2;
@ -377,7 +418,7 @@ make_env(const struct interface *ifp, const char *reason)
if (efprintf(fp, "syslog_debug=true") == -1) if (efprintf(fp, "syslog_debug=true") == -1)
goto eexit; goto eexit;
} }
if (*ifp->profile) { if (*ifp->profile != '\0') {
if (efprintf(fp, "profile=%s", ifp->profile) == -1) if (efprintf(fp, "profile=%s", ifp->profile) == -1)
goto eexit; goto eexit;
} }
@ -476,38 +517,8 @@ dumplease:
fp = NULL; fp = NULL;
#endif #endif
/* Count the terminated env strings. if (script_buftoenv(ctx, ctx->script_buf, (size_t)buf_pos) == NULL)
* Assert that the terminations are correct. */ goto eexit;
nenv = 0;
endp = ctx->script_buf + buf_pos;
for (bufp = ctx->script_buf; bufp < endp; bufp++) {
if (*bufp == '\0') {
#ifndef NDEBUG
if (bufp + 1 < endp)
assert(*(bufp + 1) != '\0');
#endif
nenv++;
}
}
assert(*(bufp - 1) == '\0');
if (ctx->script_envlen < nenv) {
env = reallocarray(ctx->script_env, nenv + 1, sizeof(*env));
if (env == NULL)
goto eexit;
ctx->script_env = env;
ctx->script_envlen = nenv;
}
bufp = ctx->script_buf;
envp = ctx->script_env;
*envp++ = bufp++;
endp--; /* Avoid setting the last \0 to an invalid pointer */
for (; bufp < endp; bufp++) {
if (*bufp == '\0')
*envp++ = bufp + 1;
}
*envp = NULL;
return buf_pos - 1; return buf_pos - 1;
@ -620,7 +631,7 @@ script_runreason(const struct interface *ifp, const char *reason)
argv[1] = NULL; argv[1] = NULL;
logdebugx("%s: executing `%s' %s", ifp->name, argv[0], reason); logdebugx("%s: executing `%s' %s", ifp->name, argv[0], reason);
pid = exec_script(ctx, argv, ctx->script_env); pid = script_exec(ctx, argv, ctx->script_env);
if (pid == -1) if (pid == -1)
logerr("%s: %s", __func__, argv[0]); logerr("%s: %s", __func__, argv[0]);
else if (pid != 0) { else if (pid != 0) {