int
iface_Name(struct iface *iface, const char *name)
{
struct ifreq ifr;
int s;
char *newname;
if ((newname = strdup(name)) == NULL) {
log_Printf(LogWARN, "iface name: strdup failed: %s\n", strerror(errno));
return 0;
}
if ((s = ID0socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
log_Printf(LogERROR, "iface name: socket(): %s\n", strerror(errno));
free(newname);
return 0;
}
strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
ifr.ifr_data = newname;
if (ID0ioctl(s, SIOCSIFNAME, (caddr_t)&ifr) < 0) {
log_Printf(LogWARN, "iface name: ioctl(SIOCSIFNAME, %s -> %s): %s\n",
name, newname, strerror(errno));
free(newname);
return 0;
}
free(iface->name);
iface->name = newname;
return 1;
}
int
iface_Delete(struct iface *iface, struct ncp *ncp, const struct ncpaddr *del)
{
struct ncpaddr found;
unsigned n;
int res, s;
if ((s = ID0socket(ncpaddr_family(del), SOCK_DGRAM, 0)) == -1) {
log_Printf(LogERROR, "iface_Delete: socket(): %s\n", strerror(errno));
return 0;
}
for (n = res = 0; n < iface->addrs; n++) {
ncprange_getaddr(&iface->addr[n].ifa, &found);
if (ncpaddr_equal(&found, del)) {
if (iface_addr_Zap(iface->name, iface->addr + n, s)) {
ncp_IfaceAddrDeleted(ncp, iface->addr + n);
bcopy(iface->addr + n + 1, iface->addr + n,
(iface->addrs - n - 1) * sizeof *iface->addr);
iface->addrs--;
res = 1;
}
break;
}
}
close(s);
return res;
}
void
iface_Clear(struct iface *iface, struct ncp *ncp, int family, int how)
{
int addrs, af, inskip, in6skip, s4 = -1, s6 = -1, *s;
unsigned n;
if (iface->addrs) {
inskip = in6skip = how == IFACE_CLEAR_ALL ? 0 : 1;
addrs = 0;
for (n = 0; n < iface->addrs; n++) {
af = ncprange_family(&iface->addr[n].ifa);
if (family == 0 || family == af) {
if (!iface->addr[n].system && (how & IFACE_SYSTEM))
continue;
switch (af) {
case AF_INET:
if (inskip) {
inskip = 0;
continue;
}
s = &s4;
break;
#ifndef NOINET6
case AF_INET6:
if (in6skip) {
in6skip = 0;
continue;
}
s = &s6;
break;
#endif
default:
continue;
}
if (*s == -1 && (*s = ID0socket(af, SOCK_DGRAM, 0)) == -1)
log_Printf(LogERROR, "iface_Clear: socket(): %s\n", strerror(errno));
else if (iface_addr_Zap(iface->name, iface->addr + n, *s)) {
ncp_IfaceAddrDeleted(ncp, iface->addr + n);
bcopy(iface->addr + n + 1, iface->addr + n,
(iface->addrs - n - 1) * sizeof *iface->addr);
iface->addrs--;
n--;
}
}
}
/* Don't bother realloc()ing - we have little to gain */
if (s4)
close(s4);
if (s6)
close(s6);
}
}
static int
ipv6_available(void)
{
int s;
if ((s = ID0socket(PF_INET6, SOCK_DGRAM, 0)) == -1)
return 0;
close(s);
return 1;
}
static int
arp_ProxySub(struct bundle *bundle, struct in_addr addr, int add)
{
int routes;
/*
* Get the hardware address of an interface on the same subnet as our local
* address.
*/
memset(&arpmsg, 0, sizeof arpmsg);
if (!arp_EtherAddr(addr, &arpmsg.hwa, 0)) {
log_Printf(LogWARN, "%s: Cannot determine ethernet address for proxy ARP\n",
inet_ntoa(addr));
return 0;
}
routes = ID0socket(PF_ROUTE, SOCK_RAW, AF_INET);
if (routes < 0) {
log_Printf(LogERROR, "arp_SetProxy: opening routing socket: %s\n",
strerror(errno));
return 0;
}
arpmsg.hdr.rtm_type = add ? RTM_ADD : RTM_DELETE;
arpmsg.hdr.rtm_flags = RTF_ANNOUNCE | RTF_HOST | RTF_STATIC | RTF_LLDATA;
arpmsg.hdr.rtm_version = RTM_VERSION;
arpmsg.hdr.rtm_seq = ++bundle->routing_seq;
arpmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY;
arpmsg.hdr.rtm_inits = RTV_EXPIRE;
arpmsg.dst.sin_len = sizeof(struct sockaddr_inarp);
arpmsg.dst.sin_family = AF_INET;
arpmsg.dst.sin_addr.s_addr = addr.s_addr;
arpmsg.dst.sin_other = SIN_PROXY;
arpmsg.hdr.rtm_msglen = (char *) &arpmsg.hwa - (char *) &arpmsg
+ arpmsg.hwa.sdl_len;
if (ID0write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0 &&
!(!add && errno == ESRCH)) {
log_Printf(LogERROR, "%s proxy arp entry %s: %s\n",
add ? "Add" : "Delete", inet_ntoa(addr), strerror(errno));
close(routes);
return 0;
}
close(routes);
return 1;
}
static int
iface_ChangeFlags(const char *ifname, int flags, int how)
{
struct ifreq ifrq;
int s, new_flags;
s = ID0socket(PF_INET, SOCK_DGRAM, 0);
if (s < 0) {
log_Printf(LogERROR, "iface_ChangeFlags: socket: %s\n", strerror(errno));
return 0;
}
memset(&ifrq, '\0', sizeof ifrq);
strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1);
ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0';
if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) {
log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCGIFFLAGS): %s\n",
strerror(errno));
close(s);
return 0;
}
#ifdef __FreeBSD__
new_flags = (ifrq.ifr_flags & 0xffff) | (ifrq.ifr_flagshigh << 16);
#else
new_flags = ifrq.ifr_flags & 0xffff;
#endif
if (how == IFACE_ADDFLAGS)
new_flags |= flags;
else
new_flags &= ~flags;
ifrq.ifr_flags = new_flags & 0xffff;
#ifdef __FreeBSD__
ifrq.ifr_flagshigh = new_flags >> 16;
#endif
if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) {
log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCSIFFLAGS): %s\n",
strerror(errno));
close(s);
return 0;
}
close(s);
return 1; /* Success */
}
void
iface_Destroy(struct iface *iface)
{
struct ifreq ifr;
int s;
if (iface != NULL) {
if ((s = ID0socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
log_Printf(LogERROR, "iface_Destroy: socket(): %s\n", strerror(errno));
} else {
strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
if (ID0ioctl(s, SIOCIFDESTROY, (caddr_t)&ifr) < 0)
log_Printf(LogWARN, "iface_Destroy: ioctl(SIOCIFDESTROY, %s): %s\n",
iface->name, strerror(errno));
}
iface_Free(iface);
}
}
static int
iface_ChangeFlags(const char *ifname, int flags, int how)
{
struct ifreq ifrq;
int s;
s = ID0socket(PF_INET, SOCK_DGRAM, 0);
if (s < 0) {
log_Printf(LogERROR, "iface_ChangeFlags: socket: %s\n", strerror(errno));
return 0;
}
memset(&ifrq, '\0', sizeof ifrq);
strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1);
ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0';
if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) {
log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCGIFFLAGS): %s\n",
strerror(errno));
close(s);
return 0;
}
if (how == IFACE_ADDFLAGS)
ifrq.ifr_flags |= flags;
else
ifrq.ifr_flags &= ~flags;
if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) {
log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCSIFFLAGS): %s\n",
strerror(errno));
close(s);
return 0;
}
close(s);
return 1; /* Success */
}
void
rt_Update(struct bundle *bundle, const struct sockaddr *dst,
const struct sockaddr *gw, const struct sockaddr *mask)
{
struct ncprange ncpdst;
struct rtmsg rtmes;
char *p;
int s, wb;
s = ID0socket(PF_ROUTE, SOCK_RAW, 0);
if (s < 0) {
log_Printf(LogERROR, "rt_Update: socket(): %s\n", strerror(errno));
return;
}
memset(&rtmes, '\0', sizeof rtmes);
rtmes.m_rtm.rtm_version = RTM_VERSION;
rtmes.m_rtm.rtm_type = RTM_CHANGE;
rtmes.m_rtm.rtm_addrs = 0;
rtmes.m_rtm.rtm_seq = ++bundle->routing_seq;
rtmes.m_rtm.rtm_pid = getpid();
rtmes.m_rtm.rtm_flags = RTF_UP | RTF_STATIC;
if (bundle->ncp.cfg.sendpipe > 0) {
rtmes.m_rtm.rtm_rmx.rmx_sendpipe = bundle->ncp.cfg.sendpipe;
rtmes.m_rtm.rtm_inits |= RTV_SPIPE;
}
if (bundle->ncp.cfg.recvpipe > 0) {
rtmes.m_rtm.rtm_rmx.rmx_recvpipe = bundle->ncp.cfg.recvpipe;
rtmes.m_rtm.rtm_inits |= RTV_RPIPE;
}
rtmes.m_rtm.rtm_rmx.rmx_mtu = bundle->iface->mtu;
rtmes.m_rtm.rtm_inits |= RTV_MTU;
p = rtmes.m_space;
if (dst) {
rtmes.m_rtm.rtm_addrs |= RTA_DST;
p += memcpy_roundup(p, dst, dst->sa_len);
}
rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY;
p += memcpy_roundup(p, gw, gw->sa_len);
if (mask) {
rtmes.m_rtm.rtm_addrs |= RTA_NETMASK;
p += memcpy_roundup(p, mask, mask->sa_len);
}
rtmes.m_rtm.rtm_msglen = p - (char *)&rtmes;
wb = ID0write(s, &rtmes, rtmes.m_rtm.rtm_msglen);
if (wb < 0) {
ncprange_setsa(&ncpdst, dst, mask);
log_Printf(LogTCPIP, "rt_Update failure:\n");
log_Printf(LogTCPIP, "rt_Update: Dst = %s\n", ncprange_ntoa(&ncpdst));
if (rtmes.m_rtm.rtm_errno == 0)
log_Printf(LogWARN, "%s: Change route failed: errno: %s\n",
ncprange_ntoa(&ncpdst), strerror(errno));
else
log_Printf(LogWARN, "%s: Change route failed: %s\n",
ncprange_ntoa(&ncpdst), strerror(rtmes.m_rtm.rtm_errno));
}
close(s);
}
int
rt_Set(struct bundle *bundle, int cmd, const struct ncprange *dst,
const struct ncpaddr *gw, int bang, int quiet)
{
struct rtmsg rtmes;
int s, nb, wb;
char *cp;
const char *cmdstr;
struct sockaddr_storage sadst, samask, sagw;
int result = 1;
if (bang)
cmdstr = (cmd == RTM_ADD ? "Add!" : "Delete!");
else
cmdstr = (cmd == RTM_ADD ? "Add" : "Delete");
s = ID0socket(PF_ROUTE, SOCK_RAW, 0);
if (s < 0) {
log_Printf(LogERROR, "rt_Set: socket(): %s\n", strerror(errno));
return result;
}
memset(&rtmes, '\0', sizeof rtmes);
rtmes.m_rtm.rtm_version = RTM_VERSION;
rtmes.m_rtm.rtm_type = cmd;
rtmes.m_rtm.rtm_addrs = RTA_DST;
rtmes.m_rtm.rtm_seq = ++bundle->routing_seq;
rtmes.m_rtm.rtm_pid = getpid();
rtmes.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC;
if (cmd == RTM_ADD) {
if (bundle->ncp.cfg.sendpipe > 0) {
rtmes.m_rtm.rtm_rmx.rmx_sendpipe = bundle->ncp.cfg.sendpipe;
rtmes.m_rtm.rtm_inits |= RTV_SPIPE;
}
if (bundle->ncp.cfg.recvpipe > 0) {
rtmes.m_rtm.rtm_rmx.rmx_recvpipe = bundle->ncp.cfg.recvpipe;
rtmes.m_rtm.rtm_inits |= RTV_RPIPE;
}
}
ncprange_getsa(dst, &sadst, &samask);
#if defined(__KAME__) && !defined(NOINET6)
add_scope((struct sockaddr *)&sadst, bundle->iface->index);
#endif
cp = rtmes.m_space;
cp += memcpy_roundup(cp, &sadst, sadst.ss_len);
if (cmd == RTM_ADD) {
if (gw == NULL) {
log_Printf(LogERROR, "rt_Set: Program error\n");
close(s);
return result;
}
ncpaddr_getsa(gw, &sagw);
#if defined(__KAME__) && !defined(NOINET6)
add_scope((struct sockaddr *)&sagw, bundle->iface->index);
#endif
if (ncpaddr_isdefault(gw)) {
if (!quiet)
log_Printf(LogERROR, "rt_Set: Cannot add a route with"
" gateway 0.0.0.0\n");
close(s);
return result;
} else {
cp += memcpy_roundup(cp, &sagw, sagw.ss_len);
rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY;
}
}
if (!ncprange_ishost(dst)) {
cp += memcpy_roundup(cp, &samask, samask.ss_len);
rtmes.m_rtm.rtm_addrs |= RTA_NETMASK;
}
nb = cp - (char *)&rtmes;
rtmes.m_rtm.rtm_msglen = nb;
wb = ID0write(s, &rtmes, nb);
if (wb < 0) {
log_Printf(LogTCPIP, "rt_Set failure:\n");
log_Printf(LogTCPIP, "rt_Set: Cmd = %s\n", cmdstr);
log_Printf(LogTCPIP, "rt_Set: Dst = %s\n", ncprange_ntoa(dst));
if (gw != NULL)
log_Printf(LogTCPIP, "rt_Set: Gateway = %s\n", ncpaddr_ntoa(gw));
failed:
if (cmd == RTM_ADD && (rtmes.m_rtm.rtm_errno == EEXIST ||
(rtmes.m_rtm.rtm_errno == 0 && errno == EEXIST))) {
if (!bang) {
log_Printf(LogWARN, "Add route failed: %s already exists\n",
ncprange_ntoa(dst));
result = 0; /* Don't add to our dynamic list */
} else {
rtmes.m_rtm.rtm_type = cmd = RTM_CHANGE;
if ((wb = ID0write(s, &rtmes, nb)) < 0)
goto failed;
}
} else if (cmd == RTM_DELETE &&
(rtmes.m_rtm.rtm_errno == ESRCH ||
(rtmes.m_rtm.rtm_errno == 0 && errno == ESRCH))) {
if (!bang)
log_Printf(LogWARN, "Del route failed: %s: Non-existent\n",
ncprange_ntoa(dst));
} else if (rtmes.m_rtm.rtm_errno == 0) {
if (!quiet || errno != ENETUNREACH)
log_Printf(LogWARN, "%s route failed: %s: errno: %s\n", cmdstr,
ncprange_ntoa(dst), strerror(errno));
} else
log_Printf(LogWARN, "%s route failed: %s: %s\n",
cmdstr, ncprange_ntoa(dst), strerror(rtmes.m_rtm.rtm_errno));
}
if (log_IsKept(LogDEBUG)) {
char gwstr[40];
if (gw)
snprintf(gwstr, sizeof gwstr, "%s", ncpaddr_ntoa(gw));
else
snprintf(gwstr, sizeof gwstr, "<none>");
log_Printf(LogDEBUG, "wrote %d: cmd = %s, dst = %s, gateway = %s\n",
wb, cmdstr, ncprange_ntoa(dst), gwstr);
}
close(s);
return result;
}
int
iface_Add(struct iface *iface, struct ncp *ncp, const struct ncprange *ifa,
const struct ncpaddr *peer, int how)
{
int af, removed, s;
unsigned n;
struct ncpaddr ncplocal;
struct iface_addr *addr, newaddr;
af = ncprange_family(ifa);
if ((s = ID0socket(af, SOCK_DGRAM, 0)) == -1) {
log_Printf(LogERROR, "iface_Add: socket(): %s\n", strerror(errno));
return 0;
}
ncprange_getaddr(ifa, &ncplocal);
for (n = 0; n < iface->addrs; n++) {
if (ncprange_contains(&iface->addr[n].ifa, &ncplocal) ||
ncpaddr_equal(&iface->addr[n].peer, peer)) {
/* Replace this sockaddr */
if (!(how & IFACE_FORCE_ADD)) {
close(s);
return 0; /* errno = EEXIST; */
}
if (ncprange_equal(&iface->addr[n].ifa, ifa) &&
ncpaddr_equal(&iface->addr[n].peer, peer)) {
close(s);
ncp_IfaceAddrAdded(ncp, iface->addr + n);
return 1; /* Already there */
}
removed = iface_addr_Zap(iface->name, iface->addr + n, s);
if (removed)
ncp_IfaceAddrDeleted(ncp, iface->addr + n);
ncprange_copy(&iface->addr[n].ifa, ifa);
ncpaddr_copy(&iface->addr[n].peer, peer);
if (!iface_addr_Add(iface->name, iface->addr + n, s)) {
if (removed) {
bcopy(iface->addr + n + 1, iface->addr + n,
(iface->addrs - n - 1) * sizeof *iface->addr);
iface->addrs--;
n--;
}
close(s);
return 0;
}
close(s);
ncp_IfaceAddrAdded(ncp, iface->addr + n);
return 1;
}
}
addr = (struct iface_addr *)realloc
(iface->addr, (iface->addrs + 1) * sizeof iface->addr[0]);
if (addr == NULL) {
log_Printf(LogERROR, "iface_inAdd: realloc: %s\n", strerror(errno));
close(s);
return 0;
}
iface->addr = addr;
ncprange_copy(&newaddr.ifa, ifa);
ncpaddr_copy(&newaddr.peer, peer);
newaddr.system = !!(how & IFACE_SYSTEM);
if (!iface_addr_Add(iface->name, &newaddr, s)) {
close(s);
return 0;
}
if (how & IFACE_ADD_FIRST) {
/* Stuff it at the start of our list */
n = 0;
bcopy(iface->addr, iface->addr + 1, iface->addrs * sizeof *iface->addr);
} else
n = iface->addrs;
iface->addrs++;
memcpy(iface->addr + n, &newaddr, sizeof(*iface->addr));
close(s);
ncp_IfaceAddrAdded(ncp, iface->addr + n);
return 1;
}
int
iface_Descr(struct cmdargs const *arg)
{
struct ifreq ifr;
struct iface *iface;
size_t sz, len;
int s, n, ifdescr_maxlen;
char *descr;
sz = sizeof(int);
if (sysctlbyname("net.ifdescr_maxlen", &ifdescr_maxlen, &sz, NULL, 0) < 0) {
log_Printf(LogERROR, "iface descr: sysctl failed: %s\n", strerror(errno));
return 1;
}
if (ifdescr_maxlen < 1) {
log_Printf(LogERROR, "iface descr: sysctl net.ifdescr_maxlen < 1\n");
return 1;
}
sz = sizeof(char) * ifdescr_maxlen;
if ((descr = malloc(sz)) == NULL) {
log_Printf(LogERROR, "iface descr: malloc failed: %s\n", strerror(errno));
return 1;
}
*descr = '\0';
n = arg->argn;
while (n < arg->argc) {
if (n > arg->argn && (len = strlcat(descr, " ", sz)) >= sz)
break;
if ((len = strlcat(descr, arg->argv[n], sz)) >= sz)
break;
++n;
}
if (len >= sz) {
log_Printf(LogERROR, "iface descr: description exceeds maximum (%d)\n",
ifdescr_maxlen-1);
free(descr);
return 1;
}
if ((s = ID0socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
log_Printf(LogERROR, "iface descr: socket(): %s\n", strerror(errno));
free(descr);
return 1;
}
iface = arg->bundle->iface;
strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
ifr.ifr_buffer.length = strlen(descr) + 1;
ifr.ifr_buffer.buffer = descr;
if (ID0ioctl(s, SIOCSIFDESCR, (caddr_t)&ifr) < 0) {
log_Printf(LogWARN, "iface descr: ioctl(SIOCSIFDESCR, %s): %s\n",
descr, strerror(errno));
free(descr);
return 1;
}
free(iface->descr);
iface->descr = descr;
return 0;
}
