| /* dnsmasq is Copyright (c) 2000-2009 Simon Kelley |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; version 2 dated June, 1991, or |
| (at your option) version 3 dated 29 June, 2007. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include "dnsmasq.h" |
| |
| #ifdef HAVE_DHCP |
| |
| struct iface_param { |
| struct in_addr relay, primary; |
| struct dhcp_context* current; |
| int ind; |
| }; |
| |
| static int complete_context(struct in_addr local, int if_index, struct in_addr netmask, |
| struct in_addr broadcast, void* vparam); |
| |
| void dhcp_init(void) { |
| int fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); |
| struct sockaddr_in saddr; |
| int oneopt = 1; |
| #if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT) |
| int mtu = IP_PMTUDISC_DONT; |
| #endif |
| |
| if (fd == -1) die(_("cannot create DHCP socket: %s"), NULL, EC_BADNET); |
| |
| if (!fix_fd(fd) || |
| #if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT) |
| setsockopt(fd, SOL_IP, IP_MTU_DISCOVER, &mtu, sizeof(mtu)) == -1 || |
| #endif |
| #if defined(HAVE_LINUX_NETWORK) |
| setsockopt(fd, SOL_IP, IP_PKTINFO, &oneopt, sizeof(oneopt)) == -1 || |
| #else |
| setsockopt(fd, IPPROTO_IP, IP_RECVIF, &oneopt, sizeof(oneopt)) == -1 || |
| #endif |
| setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &oneopt, sizeof(oneopt)) == -1) |
| die(_("failed to set options on DHCP socket: %s"), NULL, EC_BADNET); |
| |
| /* When bind-interfaces is set, there might be more than one dnmsasq |
| instance binding port 67. That's OK if they serve different networks. |
| Need to set REUSEADDR to make this posible, or REUSEPORT on *BSD. */ |
| if (daemon->options & OPT_NOWILD) { |
| #ifdef SO_REUSEPORT |
| int rc = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &oneopt, sizeof(oneopt)); |
| #else |
| int rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &oneopt, sizeof(oneopt)); |
| #endif |
| if (rc == -1) |
| die(_("failed to set SO_REUSE{ADDR|PORT} on DHCP socket: %s"), NULL, EC_BADNET); |
| } |
| |
| memset(&saddr, 0, sizeof(saddr)); |
| saddr.sin_family = AF_INET; |
| saddr.sin_port = htons(daemon->dhcp_server_port); |
| saddr.sin_addr.s_addr = INADDR_ANY; |
| |
| if (bind(fd, (struct sockaddr*) &saddr, sizeof(struct sockaddr_in))) |
| die(_("failed to bind DHCP server socket: %s"), NULL, EC_BADNET); |
| |
| #ifdef __ANDROID__ |
| if (setsockopt(fd, SOL_SOCKET, SO_MARK, &daemon->listen_mark, sizeof(daemon->listen_mark)) == -1) |
| die(_("failed to set DHCP socket mark: %s"), NULL, EC_BADNET); |
| #endif /* __ANDROID__ */ |
| |
| daemon->dhcpfd = fd; |
| |
| check_dhcp_hosts(1); |
| |
| daemon->dhcp_packet.iov_len = sizeof(struct dhcp_packet); |
| daemon->dhcp_packet.iov_base = safe_malloc(daemon->dhcp_packet.iov_len); |
| } |
| |
| void dhcp_packet(time_t now) { |
| struct dhcp_packet* mess; |
| struct dhcp_context* context; |
| struct iname* tmp; |
| struct ifreq ifr; |
| struct msghdr msg; |
| struct sockaddr_in dest; |
| struct cmsghdr* cmptr; |
| struct iovec iov; |
| ssize_t sz; |
| int iface_index = 0, unicast_dest = 0, is_inform = 0; |
| struct in_addr iface_addr, *addrp = NULL; |
| struct iface_param parm; |
| |
| union { |
| struct cmsghdr align; /* this ensures alignment */ |
| #if defined(HAVE_LINUX_NETWORK) |
| char control[CMSG_SPACE(sizeof(struct in_pktinfo))]; |
| #endif |
| } control_u; |
| |
| msg.msg_control = NULL; |
| msg.msg_controllen = 0; |
| msg.msg_name = NULL; |
| msg.msg_namelen = 0; |
| msg.msg_iov = &daemon->dhcp_packet; |
| msg.msg_iovlen = 1; |
| |
| while (1) { |
| msg.msg_flags = 0; |
| while ((sz = recvmsg(daemon->dhcpfd, &msg, MSG_PEEK | MSG_TRUNC)) == -1 && errno == EINTR) |
| ; |
| |
| if (sz == -1) return; |
| |
| if (!(msg.msg_flags & MSG_TRUNC)) break; |
| |
| /* Very new Linux kernels return the actual size needed, |
| older ones always return truncated size */ |
| if ((size_t) sz == daemon->dhcp_packet.iov_len) { |
| if (!expand_buf(&daemon->dhcp_packet, sz + 100)) return; |
| } else { |
| expand_buf(&daemon->dhcp_packet, sz); |
| break; |
| } |
| } |
| |
| /* expand_buf may have moved buffer */ |
| mess = (struct dhcp_packet*) daemon->dhcp_packet.iov_base; |
| msg.msg_controllen = sizeof(control_u); |
| msg.msg_control = control_u.control; |
| msg.msg_flags = 0; |
| msg.msg_name = &dest; |
| msg.msg_namelen = sizeof(dest); |
| |
| while ((sz = recvmsg(daemon->dhcpfd, &msg, 0)) == -1 && errno == EINTR) |
| ; |
| |
| if ((msg.msg_flags & MSG_TRUNC) || sz < (ssize_t)(sizeof(*mess) - sizeof(mess->options))) |
| return; |
| |
| #if defined(HAVE_LINUX_NETWORK) |
| if (msg.msg_controllen >= sizeof(struct cmsghdr)) |
| for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr)) |
| if (cmptr->cmsg_level == SOL_IP && cmptr->cmsg_type == IP_PKTINFO) { |
| iface_index = ((struct in_pktinfo*) CMSG_DATA(cmptr))->ipi_ifindex; |
| if (((struct in_pktinfo*) CMSG_DATA(cmptr))->ipi_addr.s_addr != INADDR_BROADCAST) |
| unicast_dest = 1; |
| } |
| #endif |
| |
| if (!indextoname(daemon->dhcpfd, iface_index, ifr.ifr_name)) return; |
| |
| #ifdef MSG_BCAST |
| /* OpenBSD tells us when a packet was broadcast */ |
| if (!(msg.msg_flags & MSG_BCAST)) unicast_dest = 1; |
| #endif |
| |
| ifr.ifr_addr.sa_family = AF_INET; |
| if (ioctl(daemon->dhcpfd, SIOCGIFADDR, &ifr) != -1) { |
| addrp = &iface_addr; |
| iface_addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr; |
| } |
| |
| if (!iface_check(AF_INET, (struct all_addr*) addrp, ifr.ifr_name, &iface_index)) return; |
| |
| for (tmp = daemon->dhcp_except; tmp; tmp = tmp->next) |
| if (tmp->name && (strcmp(tmp->name, ifr.ifr_name) == 0)) return; |
| |
| /* interface may have been changed by alias in iface_check */ |
| if (!addrp) { |
| if (ioctl(daemon->dhcpfd, SIOCGIFADDR, &ifr) == -1) { |
| my_syslog(MS_DHCP | LOG_WARNING, _("DHCP packet received on %s which has no address"), |
| ifr.ifr_name); |
| return; |
| } else |
| iface_addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr; |
| } |
| |
| /* unlinked contexts are marked by context->current == context */ |
| for (context = daemon->dhcp; context; context = context->next) context->current = context; |
| |
| parm.relay = mess->giaddr; |
| parm.primary = iface_addr; |
| parm.current = NULL; |
| parm.ind = iface_index; |
| |
| if (!iface_enumerate(&parm, complete_context, NULL)) return; |
| lease_prune(NULL, now); /* lose any expired leases */ |
| iov.iov_len = dhcp_reply(parm.current, ifr.ifr_name, iface_index, (size_t) sz, now, |
| unicast_dest, &is_inform); |
| lease_update_file(now); |
| lease_update_dns(); |
| |
| if (iov.iov_len == 0) return; |
| |
| msg.msg_name = &dest; |
| msg.msg_namelen = sizeof(dest); |
| msg.msg_control = NULL; |
| msg.msg_controllen = 0; |
| msg.msg_iov = &iov; |
| iov.iov_base = daemon->dhcp_packet.iov_base; |
| |
| /* packet buffer may have moved */ |
| mess = (struct dhcp_packet*) daemon->dhcp_packet.iov_base; |
| |
| if (mess->giaddr.s_addr) { |
| /* Send to BOOTP relay */ |
| dest.sin_port = htons(daemon->dhcp_server_port); |
| dest.sin_addr = mess->giaddr; |
| } else if (mess->ciaddr.s_addr) { |
| /* If the client's idea of its own address tallys with |
| the source address in the request packet, we believe the |
| source port too, and send back to that. If we're replying |
| to a DHCPINFORM, trust the source address always. */ |
| if ((!is_inform && dest.sin_addr.s_addr != mess->ciaddr.s_addr) || dest.sin_port == 0 || |
| dest.sin_addr.s_addr == 0) { |
| dest.sin_port = htons(daemon->dhcp_client_port); |
| dest.sin_addr = mess->ciaddr; |
| } |
| } |
| #if defined(HAVE_LINUX_NETWORK) |
| else if ((ntohs(mess->flags) & 0x8000) || mess->hlen == 0 || |
| mess->hlen > sizeof(ifr.ifr_addr.sa_data) || mess->htype == 0) { |
| /* broadcast to 255.255.255.255 (or mac address invalid) */ |
| struct in_pktinfo* pkt; |
| msg.msg_control = control_u.control; |
| msg.msg_controllen = sizeof(control_u); |
| cmptr = CMSG_FIRSTHDR(&msg); |
| pkt = (struct in_pktinfo*) CMSG_DATA(cmptr); |
| pkt->ipi_ifindex = iface_index; |
| pkt->ipi_spec_dst.s_addr = 0; |
| msg.msg_controllen = cmptr->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo)); |
| cmptr->cmsg_level = SOL_IP; |
| cmptr->cmsg_type = IP_PKTINFO; |
| dest.sin_addr.s_addr = INADDR_BROADCAST; |
| dest.sin_port = htons(daemon->dhcp_client_port); |
| } else { |
| /* unicast to unconfigured client. Inject mac address direct into ARP cache. |
| struct sockaddr limits size to 14 bytes. */ |
| struct arpreq req; |
| dest.sin_addr = mess->yiaddr; |
| dest.sin_port = htons(daemon->dhcp_client_port); |
| *((struct sockaddr_in*) &req.arp_pa) = dest; |
| req.arp_ha.sa_family = mess->htype; |
| memcpy(req.arp_ha.sa_data, mess->chaddr, mess->hlen); |
| strncpy(req.arp_dev, ifr.ifr_name, 16); |
| req.arp_flags = ATF_COM; |
| ioctl(daemon->dhcpfd, SIOCSARP, &req); |
| } |
| #endif |
| |
| while (sendmsg(daemon->dhcpfd, &msg, 0) == -1 && retry_send()) |
| ; |
| } |
| |
| /* This is a complex routine: it gets called with each (address,netmask,broadcast) triple |
| of each interface (and any relay address) and does the following things: |
| |
| 1) Discards stuff for interfaces other than the one on which a DHCP packet just arrived. |
| 2) Fills in any netmask and broadcast addresses which have not been explicitly configured. |
| 3) Fills in local (this host) and router (this host or relay) addresses. |
| 4) Links contexts which are valid for hosts directly connected to the arrival interface on |
| ->current. |
| |
| Note that the current chain may be superceded later for configured hosts or those coming via |
| gateways. */ |
| |
| static int complete_context(struct in_addr local, int if_index, struct in_addr netmask, |
| struct in_addr broadcast, void* vparam) { |
| struct dhcp_context* context; |
| struct iface_param* param = vparam; |
| |
| for (context = daemon->dhcp; context; context = context->next) { |
| if (!(context->flags & CONTEXT_NETMASK) && (is_same_net(local, context->start, netmask) || |
| is_same_net(local, context->end, netmask))) { |
| if (context->netmask.s_addr != netmask.s_addr && |
| !(is_same_net(local, context->start, netmask) && |
| is_same_net(local, context->end, netmask))) { |
| strcpy(daemon->dhcp_buff, inet_ntoa(context->start)); |
| strcpy(daemon->dhcp_buff2, inet_ntoa(context->end)); |
| my_syslog(MS_DHCP | LOG_WARNING, |
| _("DHCP range %s -- %s is not consistent with netmask %s"), |
| daemon->dhcp_buff, daemon->dhcp_buff2, inet_ntoa(netmask)); |
| } |
| context->netmask = netmask; |
| } |
| |
| if (context->netmask.s_addr) { |
| if (is_same_net(local, context->start, context->netmask) && |
| is_same_net(local, context->end, context->netmask)) { |
| /* link it onto the current chain if we've not seen it before */ |
| if (if_index == param->ind && context->current == context) { |
| context->router = local; |
| context->local = local; |
| context->current = param->current; |
| param->current = context; |
| } |
| |
| if (!(context->flags & CONTEXT_BRDCAST)) { |
| if (is_same_net(broadcast, context->start, context->netmask)) |
| context->broadcast = broadcast; |
| else |
| context->broadcast.s_addr = context->start.s_addr | ~context->netmask.s_addr; |
| } |
| } else if (param->relay.s_addr && |
| is_same_net(param->relay, context->start, context->netmask)) { |
| context->router = param->relay; |
| context->local = param->primary; |
| /* fill in missing broadcast addresses for relayed ranges */ |
| if (!(context->flags & CONTEXT_BRDCAST)) |
| context->broadcast.s_addr = context->start.s_addr | ~context->netmask.s_addr; |
| } |
| } |
| } |
| |
| return 1; |
| } |
| |
| struct dhcp_context* address_available(struct dhcp_context* context, struct in_addr taddr, |
| struct dhcp_netid* netids) { |
| /* Check is an address is OK for this network, check all |
| possible ranges. Make sure that the address isn't in use |
| by the server itself. */ |
| |
| unsigned int start, end, addr = ntohl(taddr.s_addr); |
| struct dhcp_context* tmp; |
| |
| for (tmp = context; tmp; tmp = tmp->current) |
| if (taddr.s_addr == context->router.s_addr) return NULL; |
| |
| for (tmp = context; tmp; tmp = tmp->current) { |
| start = ntohl(tmp->start.s_addr); |
| end = ntohl(tmp->end.s_addr); |
| |
| if (!(tmp->flags & CONTEXT_STATIC) && addr >= start && addr <= end && |
| match_netid(tmp->filter, netids, 1)) |
| return tmp; |
| } |
| |
| return NULL; |
| } |
| |
| struct dhcp_context* narrow_context(struct dhcp_context* context, struct in_addr taddr, |
| struct dhcp_netid* netids) { |
| /* We start of with a set of possible contexts, all on the current physical interface. |
| These are chained on ->current. |
| Here we have an address, and return the actual context correponding to that |
| address. Note that none may fit, if the address came a dhcp-host and is outside |
| any dhcp-range. In that case we return a static range if possible, or failing that, |
| any context on the correct subnet. (If there's more than one, this is a dodgy |
| configuration: maybe there should be a warning.) */ |
| |
| struct dhcp_context* tmp; |
| |
| if (!(tmp = address_available(context, taddr, netids))) { |
| for (tmp = context; tmp; tmp = tmp->current) |
| if (is_same_net(taddr, tmp->start, tmp->netmask) && (tmp->flags & CONTEXT_STATIC)) |
| break; |
| |
| if (!tmp) |
| for (tmp = context; tmp; tmp = tmp->current) |
| if (is_same_net(taddr, tmp->start, tmp->netmask)) break; |
| } |
| |
| /* Only one context allowed now */ |
| if (tmp) tmp->current = NULL; |
| |
| return tmp; |
| } |
| |
| struct dhcp_config* config_find_by_address(struct dhcp_config* configs, struct in_addr addr) { |
| struct dhcp_config* config; |
| |
| for (config = configs; config; config = config->next) |
| if ((config->flags & CONFIG_ADDR) && config->addr.s_addr == addr.s_addr) return config; |
| |
| return NULL; |
| } |
| |
| /* Is every member of check matched by a member of pool? |
| If tagnotneeded, untagged is OK */ |
| int match_netid(struct dhcp_netid* check, struct dhcp_netid* pool, int tagnotneeded) { |
| struct dhcp_netid* tmp1; |
| |
| if (!check && !tagnotneeded) return 0; |
| |
| for (; check; check = check->next) { |
| if (check->net[0] != '#') { |
| for (tmp1 = pool; tmp1; tmp1 = tmp1->next) |
| if (strcmp(check->net, tmp1->net) == 0) break; |
| if (!tmp1) return 0; |
| } else |
| for (tmp1 = pool; tmp1; tmp1 = tmp1->next) |
| if (strcmp((check->net) + 1, tmp1->net) == 0) return 0; |
| } |
| return 1; |
| } |
| |
| int address_allocate(struct dhcp_context* context, struct in_addr* addrp, unsigned char* hwaddr, |
| int hw_len, struct dhcp_netid* netids, time_t now) { |
| /* Find a free address: exclude anything in use and anything allocated to |
| a particular hwaddr/clientid/hostname in our configuration. |
| Try to return from contexts which match netids first. */ |
| |
| struct in_addr start, addr; |
| struct dhcp_context *c, *d; |
| int i, pass; |
| unsigned int j; |
| |
| /* hash hwaddr */ |
| for (j = 0, i = 0; i < hw_len; i++) j += hwaddr[i] + (hwaddr[i] << 8) + (hwaddr[i] << 16); |
| |
| for (pass = 0; pass <= 1; pass++) |
| for (c = context; c; c = c->current) |
| if (c->flags & CONTEXT_STATIC) |
| continue; |
| else if (!match_netid(c->filter, netids, pass)) |
| continue; |
| else { |
| /* pick a seed based on hwaddr then iterate until we find a free address. */ |
| start.s_addr = addr.s_addr = htonl( |
| ntohl(c->start.s_addr) + |
| ((j + c->addr_epoch) % (1 + ntohl(c->end.s_addr) - ntohl(c->start.s_addr)))); |
| |
| do { |
| /* eliminate addresses in use by the server. */ |
| for (d = context; d; d = d->current) |
| if (addr.s_addr == d->router.s_addr) break; |
| |
| /* Addresses which end in .255 and .0 are broken in Windows even when using |
| supernetting. ie dhcp-range=192.168.0.1,192.168.1.254,255,255,254.0 |
| then 192.168.0.255 is a valid IP address, but not for Windows as it's |
| in the class C range. See KB281579. We therefore don't allocate these |
| addresses to avoid hard-to-diagnose problems. Thanks Bill. */ |
| if (!d && !lease_find_by_addr(addr) && |
| !config_find_by_address(daemon->dhcp_conf, addr) && |
| (!IN_CLASSC(ntohl(addr.s_addr)) || ((ntohl(addr.s_addr) & 0xff) != 0xff && |
| ((ntohl(addr.s_addr) & 0xff) != 0x0)))) { |
| struct ping_result *r, *victim = NULL; |
| int count, |
| max = (int) (0.6 * (((float) PING_CACHE_TIME) / ((float) PING_WAIT))); |
| |
| *addrp = addr; |
| |
| if (daemon->options & OPT_NO_PING) return 1; |
| |
| /* check if we failed to ping addr sometime in the last |
| PING_CACHE_TIME seconds. If so, assume the same situation still exists. |
| This avoids problems when a stupid client bangs |
| on us repeatedly. As a final check, if we did more |
| than 60% of the possible ping checks in the last |
| PING_CACHE_TIME, we are in high-load mode, so don't do any more. */ |
| for (count = 0, r = daemon->ping_results; r; r = r->next) |
| if (difftime(now, r->time) > (float) PING_CACHE_TIME) |
| victim = r; /* old record */ |
| else if (++count == max || r->addr.s_addr == addr.s_addr) |
| return 1; |
| |
| if (icmp_ping(addr)) |
| /* address in use: perturb address selection so that we are |
| less likely to try this address again. */ |
| c->addr_epoch++; |
| else { |
| /* at this point victim may hold an expired record */ |
| if (!victim) { |
| if ((victim = whine_malloc(sizeof(struct ping_result)))) { |
| victim->next = daemon->ping_results; |
| daemon->ping_results = victim; |
| } |
| } |
| |
| /* record that this address is OK for 30s |
| without more ping checks */ |
| if (victim) { |
| victim->addr = addr; |
| victim->time = now; |
| } |
| return 1; |
| } |
| } |
| |
| addr.s_addr = htonl(ntohl(addr.s_addr) + 1); |
| |
| if (addr.s_addr == htonl(ntohl(c->end.s_addr) + 1)) addr = c->start; |
| |
| } while (addr.s_addr != start.s_addr); |
| } |
| return 0; |
| } |
| |
| static int is_addr_in_context(struct dhcp_context* context, struct dhcp_config* config) { |
| if (!context) /* called via find_config() from lease_update_from_configs() */ |
| return 1; |
| if (!(config->flags & CONFIG_ADDR)) return 1; |
| for (; context; context = context->current) |
| if (is_same_net(config->addr, context->start, context->netmask)) return 1; |
| |
| return 0; |
| } |
| |
| int config_has_mac(struct dhcp_config* config, unsigned char* hwaddr, int len, int type) { |
| struct hwaddr_config* conf_addr; |
| |
| for (conf_addr = config->hwaddr; conf_addr; conf_addr = conf_addr->next) |
| if (conf_addr->wildcard_mask == 0 && conf_addr->hwaddr_len == len && |
| (conf_addr->hwaddr_type == type || conf_addr->hwaddr_type == 0) && |
| memcmp(conf_addr->hwaddr, hwaddr, len) == 0) |
| return 1; |
| |
| return 0; |
| } |
| |
| struct dhcp_config* find_config(struct dhcp_config* configs, struct dhcp_context* context, |
| unsigned char* clid, int clid_len, unsigned char* hwaddr, |
| int hw_len, int hw_type, char* hostname) { |
| int count, new; |
| struct dhcp_config *config, *candidate; |
| struct hwaddr_config* conf_addr; |
| |
| if (clid) |
| for (config = configs; config; config = config->next) |
| if (config->flags & CONFIG_CLID) { |
| if (config->clid_len == clid_len && memcmp(config->clid, clid, clid_len) == 0 && |
| is_addr_in_context(context, config)) |
| return config; |
| |
| /* dhcpcd prefixes ASCII client IDs by zero which is wrong, but we try and |
| cope with that here */ |
| if (*clid == 0 && config->clid_len == clid_len - 1 && |
| memcmp(config->clid, clid + 1, clid_len - 1) == 0 && |
| is_addr_in_context(context, config)) |
| return config; |
| } |
| |
| for (config = configs; config; config = config->next) |
| if (config_has_mac(config, hwaddr, hw_len, hw_type) && is_addr_in_context(context, config)) |
| return config; |
| |
| if (hostname && context) |
| for (config = configs; config; config = config->next) |
| if ((config->flags & CONFIG_NAME) && hostname_isequal(config->hostname, hostname) && |
| is_addr_in_context(context, config)) |
| return config; |
| |
| /* use match with fewest wildcast octets */ |
| for (candidate = NULL, count = 0, config = configs; config; config = config->next) |
| if (is_addr_in_context(context, config)) |
| for (conf_addr = config->hwaddr; conf_addr; conf_addr = conf_addr->next) |
| if (conf_addr->wildcard_mask != 0 && conf_addr->hwaddr_len == hw_len && |
| (conf_addr->hwaddr_type == hw_type || conf_addr->hwaddr_type == 0) && |
| (new = memcmp_masked(conf_addr->hwaddr, hwaddr, hw_len, |
| conf_addr->wildcard_mask)) > count) { |
| count = new; |
| candidate = config; |
| } |
| |
| return candidate; |
| } |
| |
| void check_dhcp_hosts(int fatal) { |
| /* If the same IP appears in more than one host config, then DISCOVER |
| for one of the hosts will get the address, but REQUEST will be NAKed, |
| since the address is reserved by the other one -> protocol loop. |
| Also check that FQDNs match the domain we are using. */ |
| |
| struct dhcp_config *configs, *cp; |
| |
| for (configs = daemon->dhcp_conf; configs; configs = configs->next) { |
| char* domain; |
| |
| if ((configs->flags & DHOPT_BANK) || fatal) { |
| for (cp = configs->next; cp; cp = cp->next) |
| if ((configs->flags & cp->flags & CONFIG_ADDR) && |
| configs->addr.s_addr == cp->addr.s_addr) { |
| if (fatal) |
| die(_("duplicate IP address %s in dhcp-config directive."), |
| inet_ntoa(cp->addr), EC_BADCONF); |
| else |
| my_syslog(MS_DHCP | LOG_ERR, _("duplicate IP address %s in %s."), |
| inet_ntoa(cp->addr), daemon->dhcp_hosts_file); |
| configs->flags &= ~CONFIG_ADDR; |
| } |
| |
| /* split off domain part */ |
| if ((configs->flags & CONFIG_NAME) && (domain = strip_hostname(configs->hostname))) |
| configs->domain = domain; |
| } |
| } |
| } |
| |
| void dhcp_update_configs(struct dhcp_config* configs) { |
| /* Some people like to keep all static IP addresses in /etc/hosts. |
| This goes through /etc/hosts and sets static addresses for any DHCP config |
| records which don't have an address and whose name matches. |
| We take care to maintain the invariant that any IP address can appear |
| in at most one dhcp-host. Since /etc/hosts can be re-read by SIGHUP, |
| restore the status-quo ante first. */ |
| |
| struct dhcp_config* config; |
| struct crec* crec; |
| |
| for (config = configs; config; config = config->next) |
| if (config->flags & CONFIG_ADDR_HOSTS) config->flags &= ~(CONFIG_ADDR | CONFIG_ADDR_HOSTS); |
| |
| if (daemon->port != 0) |
| for (config = configs; config; config = config->next) |
| if (!(config->flags & CONFIG_ADDR) && (config->flags & CONFIG_NAME) && |
| (crec = cache_find_by_name(NULL, config->hostname, 0, F_IPV4)) && |
| (crec->flags & F_HOSTS)) { |
| if (cache_find_by_name(crec, config->hostname, 0, F_IPV4)) { |
| /* use primary (first) address */ |
| while (crec && !(crec->flags & F_REVERSE)) |
| crec = cache_find_by_name(crec, config->hostname, 0, F_IPV4); |
| if (!crec) continue; /* should be never */ |
| my_syslog(MS_DHCP | LOG_WARNING, |
| _("%s has more than one address in hostsfile, using %s for DHCP"), |
| config->hostname, inet_ntoa(crec->addr.addr.addr.addr4)); |
| } |
| |
| if (config_find_by_address(configs, crec->addr.addr.addr.addr4)) |
| my_syslog(MS_DHCP | LOG_WARNING, |
| _("duplicate IP address %s (%s) in dhcp-config directive"), |
| inet_ntoa(crec->addr.addr.addr.addr4), config->hostname); |
| else { |
| config->addr = crec->addr.addr.addr.addr4; |
| config->flags |= CONFIG_ADDR | CONFIG_ADDR_HOSTS; |
| } |
| } |
| } |
| |
| /* If we've not found a hostname any other way, try and see if there's one in /etc/hosts |
| for this address. If it has a domain part, that must match the set domain and |
| it gets stripped. The set of legal domain names is bigger than the set of legal hostnames |
| so check here that the domain name is legal as a hostname. */ |
| char* host_from_dns(struct in_addr addr) { |
| struct crec* lookup; |
| char* hostname = NULL; |
| char *d1, *d2; |
| |
| if (daemon->port == 0) return NULL; /* DNS disabled. */ |
| |
| lookup = cache_find_by_addr(NULL, (struct all_addr*) &addr, 0, F_IPV4); |
| if (lookup && (lookup->flags & F_HOSTS)) { |
| hostname = daemon->dhcp_buff; |
| strncpy(hostname, cache_get_name(lookup), 256); |
| hostname[255] = 0; |
| d1 = strip_hostname(hostname); |
| d2 = get_domain(addr); |
| if (!legal_hostname(hostname) || (d1 && (!d2 || !hostname_isequal(d1, d2)))) |
| hostname = NULL; |
| } |
| |
| return hostname; |
| } |
| |
| /* return domain or NULL if none. */ |
| char* strip_hostname(char* hostname) { |
| char* dot = strchr(hostname, '.'); |
| |
| if (!dot) return NULL; |
| |
| *dot = 0; /* truncate */ |
| if (strlen(dot + 1) != 0) return dot + 1; |
| |
| return NULL; |
| } |
| |
| #endif |
