1 /* 2 * dhcpcd - DHCP client daemon 3 * Copyright (c) 2006-2010 Roy Marples <roy@marples.name> 4 * All rights reserved 5 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <asm/types.h> /* Needed for 2.4 kernels */ 29 30 #include <sys/types.h> 31 #include <sys/socket.h> 32 #include <sys/ioctl.h> 33 #include <sys/param.h> 34 35 #include <linux/netlink.h> 36 #include <linux/rtnetlink.h> 37 38 /* Support older kernels */ 39 #ifndef IFLA_WIRELESS 40 # define IFLA_WIRELESS (IFLA_MASTER + 1) 41 #endif 42 43 #include <errno.h> 44 #include <ctype.h> 45 #include <stddef.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <unistd.h> 50 51 #include "config.h" 52 #include "common.h" 53 #include "configure.h" 54 #include "dhcp.h" 55 #include "net.h" 56 57 static int sock_fd; 58 static struct sockaddr_nl sock_nl; 59 60 int if_init(struct interface * iface)61 if_init(struct interface *iface) 62 { 63 char path[PATH_MAX]; 64 FILE *fp; 65 int n; 66 67 /* We enable promote_secondaries so that we can do this 68 * add 192.168.1.2/24 69 * add 192.168.1.3/24 70 * del 192.168.1.2/24 71 * and the subnet mask moves onto 192.168.1.3/24 72 * This matches the behaviour of BSD which makes coding dhcpcd 73 * a little easier as there's just one behaviour. */ 74 snprintf(path, sizeof(path), 75 "/proc/sys/net/ipv4/conf/%s/promote_secondaries", 76 iface->name); 77 78 fp = fopen(path, "w"); 79 if (fp == NULL) 80 return errno == ENOENT ? 0 : -1; 81 n = fprintf(fp, "1"); 82 fclose(fp); 83 return n == -1 ? -1 : 0; 84 } 85 86 int if_conf(struct interface * iface)87 if_conf(struct interface *iface) 88 { 89 char path[PATH_MAX], buf[1]; 90 FILE *fp; 91 92 /* Some qeth setups require the use of the broadcast flag. */ 93 snprintf(path, sizeof(path), 94 "/sys/class/net/%s/device/layer2", 95 iface->name); 96 97 fp = fopen(path, "r"); 98 if (fp == NULL) 99 return errno == ENOENT ? 0 : -1; 100 if (fgets(buf, sizeof(buf), fp) != NULL && buf[0] == '0') 101 iface->state->options->options |= DHCPCD_BROADCAST; 102 fclose(fp); 103 return 0; 104 } 105 106 static int _open_link_socket(struct sockaddr_nl * nl)107 _open_link_socket(struct sockaddr_nl *nl) 108 { 109 int fd; 110 111 if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1) 112 return -1; 113 nl->nl_family = AF_NETLINK; 114 if (bind(fd, (struct sockaddr *)nl, sizeof(*nl)) == -1) 115 return -1; 116 set_cloexec(fd); 117 return fd; 118 } 119 120 int init_sockets(void)121 init_sockets(void) 122 { 123 if ((socket_afnet = socket(AF_INET, SOCK_DGRAM, 0)) == -1) 124 return -1; 125 set_cloexec(socket_afnet); 126 sock_fd = _open_link_socket(&sock_nl); 127 set_cloexec(sock_fd); 128 return sock_fd; 129 } 130 131 int open_link_socket(void)132 open_link_socket(void) 133 { 134 struct sockaddr_nl snl; 135 136 memset(&snl, 0, sizeof(snl)); 137 snl.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE | RTMGRP_IPV4_IFADDR; 138 return _open_link_socket(&snl); 139 } 140 141 static int get_netlink(int fd,int flags,int (* callback)(struct nlmsghdr *))142 get_netlink(int fd, int flags, 143 int (*callback)(struct nlmsghdr *)) 144 { 145 char *buf = NULL, *nbuf; 146 ssize_t buflen = 0, bytes; 147 struct nlmsghdr *nlm; 148 int r = -1; 149 150 for (;;) { 151 bytes = recv(fd, NULL, 0, 152 flags | MSG_PEEK | MSG_DONTWAIT | MSG_TRUNC); 153 if (bytes == -1) { 154 if (errno == EAGAIN) { 155 r = 0; 156 goto eexit; 157 } 158 if (errno == EINTR) 159 continue; 160 goto eexit; 161 } else if (bytes == buflen) { 162 /* Support kernels older than 2.6.22 */ 163 if (bytes == 0) 164 bytes = 512; 165 else 166 bytes *= 2; 167 } 168 if (buflen < bytes) { 169 /* Alloc 1 more so we work with older kernels */ 170 buflen = bytes + 1; 171 nbuf = realloc(buf, buflen); 172 if (nbuf == NULL) 173 goto eexit; 174 buf = nbuf; 175 } 176 bytes = recv(fd, buf, buflen, flags); 177 if (bytes == -1) { 178 if (errno == EAGAIN) { 179 r = 0; 180 goto eexit; 181 } 182 if (errno == EINTR) 183 continue; 184 goto eexit; 185 } 186 for (nlm = (struct nlmsghdr *)buf; 187 NLMSG_OK(nlm, (size_t)bytes); 188 nlm = NLMSG_NEXT(nlm, bytes)) 189 { 190 r = callback(nlm); 191 if (r != 0) 192 goto eexit; 193 } 194 } 195 196 eexit: 197 free(buf); 198 return r; 199 } 200 201 static int err_netlink(struct nlmsghdr * nlm)202 err_netlink(struct nlmsghdr *nlm) 203 { 204 struct nlmsgerr *err; 205 int l; 206 207 if (nlm->nlmsg_type != NLMSG_ERROR) 208 return 0; 209 l = nlm->nlmsg_len - sizeof(*nlm); 210 if ((size_t)l < sizeof(*err)) { 211 errno = EBADMSG; 212 return -1; 213 } 214 err = (struct nlmsgerr *)NLMSG_DATA(nlm); 215 if (err->error == 0) 216 return l; 217 errno = -err->error; 218 return -1; 219 } 220 221 static int link_route(struct nlmsghdr * nlm)222 link_route(struct nlmsghdr *nlm) 223 { 224 int len, idx, metric; 225 struct rtattr *rta; 226 struct rtmsg *rtm; 227 struct rt rt; 228 char ifn[IF_NAMESIZE + 1]; 229 230 if (nlm->nlmsg_type != RTM_DELROUTE) 231 return 0; 232 233 len = nlm->nlmsg_len - sizeof(*nlm); 234 if ((size_t)len < sizeof(*rtm)) { 235 errno = EBADMSG; 236 return -1; 237 } 238 rtm = NLMSG_DATA(nlm); 239 if (rtm->rtm_type != RTN_UNICAST || 240 rtm->rtm_table != RT_TABLE_MAIN || 241 rtm->rtm_family != AF_INET || 242 nlm->nlmsg_pid == (uint32_t)getpid()) 243 return 1; 244 rta = (struct rtattr *) ((char *)rtm + NLMSG_ALIGN(sizeof(*rtm))); 245 len = NLMSG_PAYLOAD(nlm, sizeof(*rtm)); 246 rt.iface = NULL; 247 rt.dest.s_addr = INADDR_ANY; 248 rt.net.s_addr = INADDR_ANY; 249 rt.gate.s_addr = INADDR_ANY; 250 rt.next = NULL; 251 metric = 0; 252 while (RTA_OK(rta, len)) { 253 switch (rta->rta_type) { 254 case RTA_DST: 255 memcpy(&rt.dest.s_addr, RTA_DATA(rta), 256 sizeof(rt.dest.s_addr)); 257 break; 258 case RTA_GATEWAY: 259 memcpy(&rt.gate.s_addr, RTA_DATA(rta), 260 sizeof(rt.gate.s_addr)); 261 break; 262 case RTA_OIF: 263 idx = *(int *)RTA_DATA(rta); 264 if (if_indextoname(idx, ifn)) 265 rt.iface = find_interface(ifn); 266 break; 267 case RTA_PRIORITY: 268 metric = *(int *)RTA_DATA(rta); 269 break; 270 } 271 rta = RTA_NEXT(rta, len); 272 } 273 if (rt.iface != NULL) { 274 if (metric == rt.iface->metric) { 275 inet_cidrtoaddr(rtm->rtm_dst_len, &rt.net); 276 route_deleted(&rt); 277 } 278 } 279 return 1; 280 } 281 282 static int link_addr(struct nlmsghdr * nlm)283 link_addr(struct nlmsghdr *nlm) 284 { 285 int len; 286 struct rtattr *rta; 287 struct ifaddrmsg *ifa; 288 struct in_addr addr, net, dest; 289 char ifn[IF_NAMESIZE + 1]; 290 struct interface *iface; 291 292 if (nlm->nlmsg_type != RTM_DELADDR && nlm->nlmsg_type != RTM_NEWADDR) 293 return 0; 294 295 len = nlm->nlmsg_len - sizeof(*nlm); 296 if ((size_t)len < sizeof(*ifa)) { 297 errno = EBADMSG; 298 return -1; 299 } 300 if (nlm->nlmsg_pid == (uint32_t)getpid()) 301 return 1; 302 ifa = NLMSG_DATA(nlm); 303 if (if_indextoname(ifa->ifa_index, ifn) == NULL) 304 return -1; 305 iface = find_interface(ifn); 306 if (iface == NULL) 307 return 1; 308 rta = (struct rtattr *) IFA_RTA(ifa); 309 len = NLMSG_PAYLOAD(nlm, sizeof(*ifa)); 310 addr.s_addr = dest.s_addr = INADDR_ANY; 311 dest.s_addr = INADDR_ANY; 312 inet_cidrtoaddr(ifa->ifa_prefixlen, &net); 313 while (RTA_OK(rta, len)) { 314 switch (rta->rta_type) { 315 case IFA_ADDRESS: 316 if (iface->flags & IFF_POINTOPOINT) { 317 memcpy(&dest.s_addr, RTA_DATA(rta), 318 sizeof(addr.s_addr)); 319 } 320 break; 321 case IFA_LOCAL: 322 memcpy(&addr.s_addr, RTA_DATA(rta), 323 sizeof(addr.s_addr)); 324 break; 325 } 326 rta = RTA_NEXT(rta, len); 327 } 328 handle_ifa(nlm->nlmsg_type, ifn, &addr, &net, &dest); 329 return 1; 330 } 331 332 static int link_netlink(struct nlmsghdr * nlm)333 link_netlink(struct nlmsghdr *nlm) 334 { 335 int len; 336 struct rtattr *rta; 337 struct ifinfomsg *ifi; 338 char ifn[IF_NAMESIZE + 1]; 339 340 len = link_route(nlm); 341 if (len != 0) 342 return len; 343 len = link_addr(nlm); 344 if (len != 0) 345 return len; 346 347 if (nlm->nlmsg_type != RTM_NEWLINK && nlm->nlmsg_type != RTM_DELLINK) 348 return 0; 349 len = nlm->nlmsg_len - sizeof(*nlm); 350 if ((size_t)len < sizeof(*ifi)) { 351 errno = EBADMSG; 352 return -1; 353 } 354 ifi = NLMSG_DATA(nlm); 355 if (ifi->ifi_flags & IFF_LOOPBACK) 356 return 1; 357 rta = (struct rtattr *) ((char *)ifi + NLMSG_ALIGN(sizeof(*ifi))); 358 len = NLMSG_PAYLOAD(nlm, sizeof(*ifi)); 359 *ifn = '\0'; 360 while (RTA_OK(rta, len)) { 361 switch (rta->rta_type) { 362 case IFLA_WIRELESS: 363 /* Ignore wireless messages */ 364 if (nlm->nlmsg_type == RTM_NEWLINK && 365 ifi->ifi_change == 0) 366 return 1; 367 break; 368 case IFLA_IFNAME: 369 strlcpy(ifn, RTA_DATA(rta), sizeof(ifn)); 370 break; 371 } 372 rta = RTA_NEXT(rta, len); 373 } 374 if (nlm->nlmsg_type == RTM_NEWLINK) 375 len = ifi->ifi_change == ~0U ? 1 : 0; 376 else 377 len = -1; 378 handle_interface(len, ifn); 379 return 1; 380 } 381 382 int manage_link(int fd)383 manage_link(int fd) 384 { 385 return get_netlink(fd, MSG_DONTWAIT, &link_netlink); 386 } 387 388 static int send_netlink(struct nlmsghdr * hdr)389 send_netlink(struct nlmsghdr *hdr) 390 { 391 int r; 392 struct iovec iov; 393 struct msghdr msg; 394 static unsigned int seq; 395 396 memset(&iov, 0, sizeof(iov)); 397 iov.iov_base = hdr; 398 iov.iov_len = hdr->nlmsg_len; 399 memset(&msg, 0, sizeof(msg)); 400 msg.msg_name = &sock_nl; 401 msg.msg_namelen = sizeof(sock_nl); 402 msg.msg_iov = &iov; 403 msg.msg_iovlen = 1; 404 /* Request a reply */ 405 hdr->nlmsg_flags |= NLM_F_ACK; 406 hdr->nlmsg_seq = ++seq; 407 408 if (sendmsg(sock_fd, &msg, 0) != -1) 409 r = get_netlink(sock_fd, 0, &err_netlink); 410 else 411 r = -1; 412 return r; 413 } 414 415 #define NLMSG_TAIL(nmsg) \ 416 ((struct rtattr *)(((ptrdiff_t)(nmsg))+NLMSG_ALIGN((nmsg)->nlmsg_len))) 417 418 static int add_attr_l(struct nlmsghdr * n,unsigned int maxlen,int type,const void * data,int alen)419 add_attr_l(struct nlmsghdr *n, unsigned int maxlen, int type, 420 const void *data, int alen) 421 { 422 int len = RTA_LENGTH(alen); 423 struct rtattr *rta; 424 425 if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len) > maxlen) { 426 errno = ENOBUFS; 427 return -1; 428 } 429 430 rta = NLMSG_TAIL(n); 431 rta->rta_type = type; 432 rta->rta_len = len; 433 memcpy(RTA_DATA(rta), data, alen); 434 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len); 435 436 return 0; 437 } 438 439 static int add_attr_32(struct nlmsghdr * n,unsigned int maxlen,int type,uint32_t data)440 add_attr_32(struct nlmsghdr *n, unsigned int maxlen, int type, uint32_t data) 441 { 442 int len = RTA_LENGTH(sizeof(data)); 443 struct rtattr *rta; 444 445 if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) { 446 errno = ENOBUFS; 447 return -1; 448 } 449 450 rta = NLMSG_TAIL(n); 451 rta->rta_type = type; 452 rta->rta_len = len; 453 memcpy(RTA_DATA(rta), &data, sizeof(data)); 454 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len; 455 456 return 0; 457 } 458 459 struct nlma 460 { 461 struct nlmsghdr hdr; 462 struct ifaddrmsg ifa; 463 char buffer[64]; 464 }; 465 466 struct nlmr 467 { 468 struct nlmsghdr hdr; 469 struct rtmsg rt; 470 char buffer[256]; 471 }; 472 473 int if_address(const struct interface * iface,const struct in_addr * address,const struct in_addr * netmask,const struct in_addr * broadcast,int action)474 if_address(const struct interface *iface, 475 const struct in_addr *address, const struct in_addr *netmask, 476 const struct in_addr *broadcast, int action) 477 { 478 struct nlma *nlm; 479 int retval = 0; 480 481 nlm = xzalloc(sizeof(*nlm)); 482 nlm->hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)); 483 nlm->hdr.nlmsg_flags = NLM_F_REQUEST; 484 if (action >= 0) { 485 nlm->hdr.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; 486 nlm->hdr.nlmsg_type = RTM_NEWADDR; 487 } else 488 nlm->hdr.nlmsg_type = RTM_DELADDR; 489 if (!(nlm->ifa.ifa_index = if_nametoindex(iface->name))) { 490 free(nlm); 491 errno = ENODEV; 492 return -1; 493 } 494 nlm->ifa.ifa_family = AF_INET; 495 nlm->ifa.ifa_prefixlen = inet_ntocidr(*netmask); 496 /* This creates the aliased interface */ 497 add_attr_l(&nlm->hdr, sizeof(*nlm), IFA_LABEL, 498 iface->name, strlen(iface->name) + 1); 499 add_attr_l(&nlm->hdr, sizeof(*nlm), IFA_LOCAL, 500 &address->s_addr, sizeof(address->s_addr)); 501 if (action >= 0 && broadcast) 502 add_attr_l(&nlm->hdr, sizeof(*nlm), IFA_BROADCAST, 503 &broadcast->s_addr, sizeof(broadcast->s_addr)); 504 505 if (send_netlink(&nlm->hdr) == -1) 506 retval = -1; 507 free(nlm); 508 return retval; 509 } 510 511 int if_route(const struct interface * iface,const struct in_addr * destination,const struct in_addr * netmask,const struct in_addr * gateway,int metric,int action)512 if_route(const struct interface *iface, 513 const struct in_addr *destination, const struct in_addr *netmask, 514 const struct in_addr *gateway, int metric, int action) 515 { 516 struct nlmr *nlm; 517 unsigned int ifindex; 518 int retval = 0; 519 520 if (!(ifindex = if_nametoindex(iface->name))) { 521 errno = ENODEV; 522 return -1; 523 } 524 525 nlm = xzalloc(sizeof(*nlm)); 526 nlm->hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); 527 nlm->hdr.nlmsg_type = RTM_NEWROUTE; 528 if (action == 0) 529 nlm->hdr.nlmsg_flags = NLM_F_REPLACE; 530 else if (action == 1) 531 nlm->hdr.nlmsg_flags = NLM_F_CREATE /*| NLM_F_EXCL*/; 532 else 533 nlm->hdr.nlmsg_type = RTM_DELROUTE; 534 nlm->hdr.nlmsg_flags |= NLM_F_REQUEST; 535 nlm->rt.rtm_family = AF_INET; 536 nlm->rt.rtm_table = RT_TABLE_MAIN; 537 538 if (action == -1 || action == -2) 539 nlm->rt.rtm_scope = RT_SCOPE_NOWHERE; 540 else { 541 nlm->hdr.nlmsg_flags |= NLM_F_CREATE /*| NLM_F_EXCL*/; 542 /* We only change route metrics for kernel routes */ 543 if (destination->s_addr == 544 (iface->addr.s_addr & iface->net.s_addr) && 545 netmask->s_addr == iface->net.s_addr) 546 nlm->rt.rtm_protocol = RTPROT_KERNEL; 547 else 548 nlm->rt.rtm_protocol = RTPROT_BOOT; 549 if (gateway->s_addr == INADDR_ANY || 550 (gateway->s_addr == destination->s_addr && 551 netmask->s_addr == INADDR_BROADCAST)) 552 nlm->rt.rtm_scope = RT_SCOPE_LINK; 553 else 554 nlm->rt.rtm_scope = RT_SCOPE_UNIVERSE; 555 nlm->rt.rtm_type = RTN_UNICAST; 556 } 557 558 nlm->rt.rtm_dst_len = inet_ntocidr(*netmask); 559 add_attr_l(&nlm->hdr, sizeof(*nlm), RTA_DST, 560 &destination->s_addr, sizeof(destination->s_addr)); 561 if (nlm->rt.rtm_protocol == RTPROT_KERNEL) { 562 add_attr_l(&nlm->hdr, sizeof(*nlm), RTA_PREFSRC, 563 &iface->addr.s_addr, sizeof(iface->addr.s_addr)); 564 } 565 /* If destination == gateway then don't add the gateway */ 566 if (destination->s_addr != gateway->s_addr || 567 netmask->s_addr != INADDR_BROADCAST) 568 add_attr_l(&nlm->hdr, sizeof(*nlm), RTA_GATEWAY, 569 &gateway->s_addr, sizeof(gateway->s_addr)); 570 571 add_attr_32(&nlm->hdr, sizeof(*nlm), RTA_OIF, ifindex); 572 add_attr_32(&nlm->hdr, sizeof(*nlm), RTA_PRIORITY, metric); 573 574 if (send_netlink(&nlm->hdr) == -1) 575 retval = -1; 576 free(nlm); 577 return retval; 578 } 579