Annotation of embedaddon/dhcp/common/socket.c, revision 1.1
1.1 ! misho 1: /* socket.c
! 2:
! 3: BSD socket interface code... */
! 4:
! 5: /*
! 6: * Copyright (c) 2004-2011 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 1995-2003 by Internet Software Consortium
! 8: *
! 9: * Permission to use, copy, modify, and distribute this software for any
! 10: * purpose with or without fee is hereby granted, provided that the above
! 11: * copyright notice and this permission notice appear in all copies.
! 12: *
! 13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 20: *
! 21: * Internet Systems Consortium, Inc.
! 22: * 950 Charter Street
! 23: * Redwood City, CA 94063
! 24: * <info@isc.org>
! 25: * https://www.isc.org/
! 26: *
! 27: * This software has been written for Internet Systems Consortium
! 28: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
! 29: * To learn more about Internet Systems Consortium, see
! 30: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
! 31: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
! 32: * ``http://www.nominum.com''.
! 33: */
! 34:
! 35: /* SO_BINDTODEVICE support added by Elliot Poger (poger@leland.stanford.edu).
! 36: * This sockopt allows a socket to be bound to a particular interface,
! 37: * thus enabling the use of DHCPD on a multihomed host.
! 38: * If SO_BINDTODEVICE is defined in your system header files, the use of
! 39: * this sockopt will be automatically enabled.
! 40: * I have implemented it under Linux; other systems should be doable also.
! 41: */
! 42:
! 43: #include "dhcpd.h"
! 44: #include <errno.h>
! 45: #include <sys/ioctl.h>
! 46: #include <sys/uio.h>
! 47: #include <sys/uio.h>
! 48: #include <signal.h>
! 49:
! 50: #if defined(sun) && defined(USE_V4_PKTINFO)
! 51: #include <sys/sysmacros.h>
! 52: #include <net/if.h>
! 53: #include <sys/sockio.h>
! 54: #include <net/if_dl.h>
! 55: #endif
! 56:
! 57: #ifdef USE_SOCKET_FALLBACK
! 58: # if !defined (USE_SOCKET_SEND)
! 59: # define if_register_send if_register_fallback
! 60: # define send_packet send_fallback
! 61: # define if_reinitialize_send if_reinitialize_fallback
! 62: # endif
! 63: #endif
! 64:
! 65: #if defined(DHCPv6)
! 66: /*
! 67: * XXX: this is gross. we need to go back and overhaul the API for socket
! 68: * handling.
! 69: */
! 70: static unsigned int global_v6_socket_references = 0;
! 71: static int global_v6_socket = -1;
! 72:
! 73: static void if_register_multicast(struct interface_info *info);
! 74: #endif
! 75:
! 76: /*
! 77: * We can use a single socket for AF_INET (similar to AF_INET6) on all
! 78: * interfaces configured for DHCP if the system has support for IP_PKTINFO
! 79: * and IP_RECVPKTINFO (for example Solaris 11).
! 80: */
! 81: #if defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && defined(USE_V4_PKTINFO)
! 82: static unsigned int global_v4_socket_references = 0;
! 83: static int global_v4_socket = -1;
! 84: #endif
! 85:
! 86: /*
! 87: * If we can't bind() to a specific interface, then we can only have
! 88: * a single socket. This variable insures that we don't try to listen
! 89: * on two sockets.
! 90: */
! 91: #if !defined(SO_BINDTODEVICE) && !defined(USE_FALLBACK)
! 92: static int once = 0;
! 93: #endif /* !defined(SO_BINDTODEVICE) && !defined(USE_FALLBACK) */
! 94:
! 95: /* Reinitializes the specified interface after an address change. This
! 96: is not required for packet-filter APIs. */
! 97:
! 98: #if defined (USE_SOCKET_SEND) || defined (USE_SOCKET_FALLBACK)
! 99: void if_reinitialize_send (info)
! 100: struct interface_info *info;
! 101: {
! 102: #if 0
! 103: #ifndef USE_SOCKET_RECEIVE
! 104: once = 0;
! 105: close (info -> wfdesc);
! 106: #endif
! 107: if_register_send (info);
! 108: #endif
! 109: }
! 110: #endif
! 111:
! 112: #ifdef USE_SOCKET_RECEIVE
! 113: void if_reinitialize_receive (info)
! 114: struct interface_info *info;
! 115: {
! 116: #if 0
! 117: once = 0;
! 118: close (info -> rfdesc);
! 119: if_register_receive (info);
! 120: #endif
! 121: }
! 122: #endif
! 123:
! 124: #if defined (USE_SOCKET_SEND) || \
! 125: defined (USE_SOCKET_RECEIVE) || \
! 126: defined (USE_SOCKET_FALLBACK)
! 127: /* Generic interface registration routine... */
! 128: int
! 129: if_register_socket(struct interface_info *info, int family,
! 130: int *do_multicast)
! 131: {
! 132: struct sockaddr_storage name;
! 133: int name_len;
! 134: int sock;
! 135: int flag;
! 136: int domain;
! 137:
! 138: /* INSIST((family == AF_INET) || (family == AF_INET6)); */
! 139:
! 140: #if !defined(SO_BINDTODEVICE) && !defined(USE_FALLBACK)
! 141: /* Make sure only one interface is registered. */
! 142: if (once) {
! 143: log_fatal ("The standard socket API can only support %s",
! 144: "hosts with a single network interface.");
! 145: }
! 146: once = 1;
! 147: #endif
! 148:
! 149: /*
! 150: * Set up the address we're going to bind to, depending on the
! 151: * address family.
! 152: */
! 153: memset(&name, 0, sizeof(name));
! 154: #ifdef DHCPv6
! 155: if (family == AF_INET6) {
! 156: struct sockaddr_in6 *addr = (struct sockaddr_in6 *)&name;
! 157: addr->sin6_family = AF_INET6;
! 158: addr->sin6_port = local_port;
! 159: /* XXX: What will happen to multicasts if this is nonzero? */
! 160: memcpy(&addr->sin6_addr,
! 161: &local_address6,
! 162: sizeof(addr->sin6_addr));
! 163: #ifdef HAVE_SA_LEN
! 164: addr->sin6_len = sizeof(*addr);
! 165: #endif
! 166: name_len = sizeof(*addr);
! 167: domain = PF_INET6;
! 168: if ((info->flags & INTERFACE_STREAMS) == INTERFACE_UPSTREAM) {
! 169: *do_multicast = 0;
! 170: }
! 171: } else {
! 172: #else
! 173: {
! 174: #endif /* DHCPv6 */
! 175: struct sockaddr_in *addr = (struct sockaddr_in *)&name;
! 176: addr->sin_family = AF_INET;
! 177: addr->sin_port = local_port;
! 178: memcpy(&addr->sin_addr,
! 179: &local_address,
! 180: sizeof(addr->sin_addr));
! 181: #ifdef HAVE_SA_LEN
! 182: addr->sin_len = sizeof(*addr);
! 183: #endif
! 184: name_len = sizeof(*addr);
! 185: domain = PF_INET;
! 186: }
! 187:
! 188: /* Make a socket... */
! 189: sock = socket(domain, SOCK_DGRAM, IPPROTO_UDP);
! 190: if (sock < 0) {
! 191: log_fatal("Can't create dhcp socket: %m");
! 192: }
! 193:
! 194: /* Set the REUSEADDR option so that we don't fail to start if
! 195: we're being restarted. */
! 196: flag = 1;
! 197: if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
! 198: (char *)&flag, sizeof(flag)) < 0) {
! 199: log_fatal("Can't set SO_REUSEADDR option on dhcp socket: %m");
! 200: }
! 201:
! 202: /* Set the BROADCAST option so that we can broadcast DHCP responses.
! 203: We shouldn't do this for fallback devices, and we can detect that
! 204: a device is a fallback because it has no ifp structure. */
! 205: if (info->ifp &&
! 206: (setsockopt(sock, SOL_SOCKET, SO_BROADCAST,
! 207: (char *)&flag, sizeof(flag)) < 0)) {
! 208: log_fatal("Can't set SO_BROADCAST option on dhcp socket: %m");
! 209: }
! 210:
! 211: #if defined(DHCPv6) && defined(SO_REUSEPORT)
! 212: /*
! 213: * We only set SO_REUSEPORT on AF_INET6 sockets, so that multiple
! 214: * daemons can bind to their own sockets and get data for their
! 215: * respective interfaces. This does not (and should not) affect
! 216: * DHCPv4 sockets; we can't yet support BSD sockets well, much
! 217: * less multiple sockets.
! 218: */
! 219: if (local_family == AF_INET6) {
! 220: flag = 1;
! 221: if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT,
! 222: (char *)&flag, sizeof(flag)) < 0) {
! 223: log_fatal("Can't set SO_REUSEPORT option on dhcp "
! 224: "socket: %m");
! 225: }
! 226: }
! 227: #endif
! 228:
! 229: /* Bind the socket to this interface's IP address. */
! 230: if (bind(sock, (struct sockaddr *)&name, name_len) < 0) {
! 231: log_error("Can't bind to dhcp address: %m");
! 232: log_error("Please make sure there is no other dhcp server");
! 233: log_error("running and that there's no entry for dhcp or");
! 234: log_error("bootp in /etc/inetd.conf. Also make sure you");
! 235: log_error("are not running HP JetAdmin software, which");
! 236: log_fatal("includes a bootp server.");
! 237: }
! 238:
! 239: #if defined(SO_BINDTODEVICE)
! 240: /* Bind this socket to this interface. */
! 241: if ((local_family != AF_INET6) && (info->ifp != NULL) &&
! 242: setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE,
! 243: (char *)(info -> ifp), sizeof(*(info -> ifp))) < 0) {
! 244: log_fatal("setsockopt: SO_BINDTODEVICE: %m");
! 245: }
! 246: #endif
! 247:
! 248: /* IP_BROADCAST_IF instructs the kernel which interface to send
! 249: * IP packets whose destination address is 255.255.255.255. These
! 250: * will be treated as subnet broadcasts on the interface identified
! 251: * by ip address (info -> primary_address). This is only known to
! 252: * be defined in SCO system headers, and may not be defined in all
! 253: * releases.
! 254: */
! 255: #if defined(SCO) && defined(IP_BROADCAST_IF)
! 256: if (info->address_count &&
! 257: setsockopt(sock, IPPROTO_IP, IP_BROADCAST_IF, &info->addresses[0],
! 258: sizeof(info->addresses[0])) < 0)
! 259: log_fatal("Can't set IP_BROADCAST_IF on dhcp socket: %m");
! 260: #endif
! 261:
! 262: #if defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && defined(USE_V4_PKTINFO)
! 263: /*
! 264: * If we turn on IP_RECVPKTINFO we will be able to receive
! 265: * the interface index information of the received packet.
! 266: */
! 267: if (family == AF_INET) {
! 268: int on = 1;
! 269: if (setsockopt(sock, IPPROTO_IP, IP_RECVPKTINFO,
! 270: &on, sizeof(on)) != 0) {
! 271: log_fatal("setsockopt: IPV_RECVPKTINFO: %m");
! 272: }
! 273: }
! 274: #endif
! 275:
! 276: #ifdef DHCPv6
! 277: /*
! 278: * If we turn on IPV6_PKTINFO, we will be able to receive
! 279: * additional information, such as the destination IP address.
! 280: * We need this to spot unicast packets.
! 281: */
! 282: if (family == AF_INET6) {
! 283: int on = 1;
! 284: #ifdef IPV6_RECVPKTINFO
! 285: /* RFC3542 */
! 286: if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO,
! 287: &on, sizeof(on)) != 0) {
! 288: log_fatal("setsockopt: IPV6_RECVPKTINFO: %m");
! 289: }
! 290: #else
! 291: /* RFC2292 */
! 292: if (setsockopt(sock, IPPROTO_IPV6, IPV6_PKTINFO,
! 293: &on, sizeof(on)) != 0) {
! 294: log_fatal("setsockopt: IPV6_PKTINFO: %m");
! 295: }
! 296: #endif
! 297: }
! 298:
! 299: if ((family == AF_INET6) &&
! 300: ((info->flags & INTERFACE_UPSTREAM) != 0)) {
! 301: int hop_limit = 32;
! 302: if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
! 303: &hop_limit, sizeof(int)) < 0) {
! 304: log_fatal("setsockopt: IPV6_MULTICAST_HOPS: %m");
! 305: }
! 306: }
! 307: #endif /* DHCPv6 */
! 308:
! 309: return sock;
! 310: }
! 311: #endif /* USE_SOCKET_SEND || USE_SOCKET_RECEIVE || USE_SOCKET_FALLBACK */
! 312:
! 313: #if defined (USE_SOCKET_SEND) || defined (USE_SOCKET_FALLBACK)
! 314: void if_register_send (info)
! 315: struct interface_info *info;
! 316: {
! 317: #ifndef USE_SOCKET_RECEIVE
! 318: info->wfdesc = if_register_socket(info, AF_INET, 0);
! 319: /* If this is a normal IPv4 address, get the hardware address. */
! 320: if (strcmp(info->name, "fallback") != 0)
! 321: get_hw_addr(info->name, &info->hw_address);
! 322: #if defined (USE_SOCKET_FALLBACK)
! 323: /* Fallback only registers for send, but may need to receive as
! 324: well. */
! 325: info->rfdesc = info->wfdesc;
! 326: #endif
! 327: #else
! 328: info->wfdesc = info->rfdesc;
! 329: #endif
! 330: if (!quiet_interface_discovery)
! 331: log_info ("Sending on Socket/%s%s%s",
! 332: info->name,
! 333: (info->shared_network ? "/" : ""),
! 334: (info->shared_network ?
! 335: info->shared_network->name : ""));
! 336: }
! 337:
! 338: #if defined (USE_SOCKET_SEND)
! 339: void if_deregister_send (info)
! 340: struct interface_info *info;
! 341: {
! 342: #ifndef USE_SOCKET_RECEIVE
! 343: close (info -> wfdesc);
! 344: #endif
! 345: info -> wfdesc = -1;
! 346:
! 347: if (!quiet_interface_discovery)
! 348: log_info ("Disabling output on Socket/%s%s%s",
! 349: info -> name,
! 350: (info -> shared_network ? "/" : ""),
! 351: (info -> shared_network ?
! 352: info -> shared_network -> name : ""));
! 353: }
! 354: #endif /* USE_SOCKET_SEND */
! 355: #endif /* USE_SOCKET_SEND || USE_SOCKET_FALLBACK */
! 356:
! 357: #ifdef USE_SOCKET_RECEIVE
! 358: void if_register_receive (info)
! 359: struct interface_info *info;
! 360: {
! 361:
! 362: #if defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && defined(USE_V4_PKTINFO)
! 363: if (global_v4_socket_references == 0) {
! 364: global_v4_socket = if_register_socket(info, AF_INET, 0);
! 365: if (global_v4_socket < 0) {
! 366: /*
! 367: * if_register_socket() fatally logs if it fails to
! 368: * create a socket, this is just a sanity check.
! 369: */
! 370: log_fatal("Failed to create AF_INET socket %s:%d",
! 371: MDL);
! 372: }
! 373: }
! 374:
! 375: info->rfdesc = global_v4_socket;
! 376: global_v4_socket_references++;
! 377: #else
! 378: /* If we're using the socket API for sending and receiving,
! 379: we don't need to register this interface twice. */
! 380: info->rfdesc = if_register_socket(info, AF_INET, 0);
! 381: #endif /* IP_PKTINFO... */
! 382: /* If this is a normal IPv4 address, get the hardware address. */
! 383: if (strcmp(info->name, "fallback") != 0)
! 384: get_hw_addr(info->name, &info->hw_address);
! 385:
! 386: if (!quiet_interface_discovery)
! 387: log_info ("Listening on Socket/%s%s%s",
! 388: info->name,
! 389: (info->shared_network ? "/" : ""),
! 390: (info->shared_network ?
! 391: info->shared_network->name : ""));
! 392: }
! 393:
! 394: void if_deregister_receive (info)
! 395: struct interface_info *info;
! 396: {
! 397: #if defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && defined(USE_V4_PKTINFO)
! 398: /* Dereference the global v4 socket. */
! 399: if ((info->rfdesc == global_v4_socket) &&
! 400: (info->wfdesc == global_v4_socket) &&
! 401: (global_v4_socket_references > 0)) {
! 402: global_v4_socket_references--;
! 403: info->rfdesc = -1;
! 404: } else {
! 405: log_fatal("Impossible condition at %s:%d", MDL);
! 406: }
! 407:
! 408: if (global_v4_socket_references == 0) {
! 409: close(global_v4_socket);
! 410: global_v4_socket = -1;
! 411: }
! 412: #else
! 413: close(info->rfdesc);
! 414: info->rfdesc = -1;
! 415: #endif /* IP_PKTINFO... */
! 416: if (!quiet_interface_discovery)
! 417: log_info ("Disabling input on Socket/%s%s%s",
! 418: info -> name,
! 419: (info -> shared_network ? "/" : ""),
! 420: (info -> shared_network ?
! 421: info -> shared_network -> name : ""));
! 422: }
! 423: #endif /* USE_SOCKET_RECEIVE */
! 424:
! 425:
! 426: #ifdef DHCPv6
! 427: /*
! 428: * This function joins the interface to DHCPv6 multicast groups so we will
! 429: * receive multicast messages.
! 430: */
! 431: static void
! 432: if_register_multicast(struct interface_info *info) {
! 433: int sock = info->rfdesc;
! 434: struct ipv6_mreq mreq;
! 435:
! 436: if (inet_pton(AF_INET6, All_DHCP_Relay_Agents_and_Servers,
! 437: &mreq.ipv6mr_multiaddr) <= 0) {
! 438: log_fatal("inet_pton: unable to convert '%s'",
! 439: All_DHCP_Relay_Agents_and_Servers);
! 440: }
! 441: mreq.ipv6mr_interface = if_nametoindex(info->name);
! 442: if (setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
! 443: &mreq, sizeof(mreq)) < 0) {
! 444: log_fatal("setsockopt: IPV6_JOIN_GROUP: %m");
! 445: }
! 446:
! 447: /*
! 448: * The relay agent code sets the streams so you know which way
! 449: * is up and down. But a relay agent shouldn't join to the
! 450: * Server address, or else you get fun loops. So up or down
! 451: * doesn't matter, we're just using that config to sense this is
! 452: * a relay agent.
! 453: */
! 454: if ((info->flags & INTERFACE_STREAMS) == 0) {
! 455: if (inet_pton(AF_INET6, All_DHCP_Servers,
! 456: &mreq.ipv6mr_multiaddr) <= 0) {
! 457: log_fatal("inet_pton: unable to convert '%s'",
! 458: All_DHCP_Servers);
! 459: }
! 460: mreq.ipv6mr_interface = if_nametoindex(info->name);
! 461: if (setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
! 462: &mreq, sizeof(mreq)) < 0) {
! 463: log_fatal("setsockopt: IPV6_JOIN_GROUP: %m");
! 464: }
! 465: }
! 466: }
! 467:
! 468: void
! 469: if_register6(struct interface_info *info, int do_multicast) {
! 470: /* Bounce do_multicast to a stack variable because we may change it. */
! 471: int req_multi = do_multicast;
! 472:
! 473: if (global_v6_socket_references == 0) {
! 474: global_v6_socket = if_register_socket(info, AF_INET6,
! 475: &req_multi);
! 476: if (global_v6_socket < 0) {
! 477: /*
! 478: * if_register_socket() fatally logs if it fails to
! 479: * create a socket, this is just a sanity check.
! 480: */
! 481: log_fatal("Impossible condition at %s:%d", MDL);
! 482: } else {
! 483: log_info("Bound to *:%d", ntohs(local_port));
! 484: }
! 485: }
! 486:
! 487: info->rfdesc = global_v6_socket;
! 488: info->wfdesc = global_v6_socket;
! 489: global_v6_socket_references++;
! 490:
! 491: if (req_multi)
! 492: if_register_multicast(info);
! 493:
! 494: get_hw_addr(info->name, &info->hw_address);
! 495:
! 496: if (!quiet_interface_discovery) {
! 497: if (info->shared_network != NULL) {
! 498: log_info("Listening on Socket/%d/%s/%s",
! 499: global_v6_socket, info->name,
! 500: info->shared_network->name);
! 501: log_info("Sending on Socket/%d/%s/%s",
! 502: global_v6_socket, info->name,
! 503: info->shared_network->name);
! 504: } else {
! 505: log_info("Listening on Socket/%s", info->name);
! 506: log_info("Sending on Socket/%s", info->name);
! 507: }
! 508: }
! 509: }
! 510:
! 511: void
! 512: if_deregister6(struct interface_info *info) {
! 513: /* Dereference the global v6 socket. */
! 514: if ((info->rfdesc == global_v6_socket) &&
! 515: (info->wfdesc == global_v6_socket) &&
! 516: (global_v6_socket_references > 0)) {
! 517: global_v6_socket_references--;
! 518: info->rfdesc = -1;
! 519: info->wfdesc = -1;
! 520: } else {
! 521: log_fatal("Impossible condition at %s:%d", MDL);
! 522: }
! 523:
! 524: if (!quiet_interface_discovery) {
! 525: if (info->shared_network != NULL) {
! 526: log_info("Disabling input on Socket/%s/%s", info->name,
! 527: info->shared_network->name);
! 528: log_info("Disabling output on Socket/%s/%s", info->name,
! 529: info->shared_network->name);
! 530: } else {
! 531: log_info("Disabling input on Socket/%s", info->name);
! 532: log_info("Disabling output on Socket/%s", info->name);
! 533: }
! 534: }
! 535:
! 536: if (global_v6_socket_references == 0) {
! 537: close(global_v6_socket);
! 538: global_v6_socket = -1;
! 539:
! 540: log_info("Unbound from *:%d", ntohs(local_port));
! 541: }
! 542: }
! 543: #endif /* DHCPv6 */
! 544:
! 545: #if defined (USE_SOCKET_SEND) || defined (USE_SOCKET_FALLBACK)
! 546: ssize_t send_packet (interface, packet, raw, len, from, to, hto)
! 547: struct interface_info *interface;
! 548: struct packet *packet;
! 549: struct dhcp_packet *raw;
! 550: size_t len;
! 551: struct in_addr from;
! 552: struct sockaddr_in *to;
! 553: struct hardware *hto;
! 554: {
! 555: int result;
! 556: #ifdef IGNORE_HOSTUNREACH
! 557: int retry = 0;
! 558: do {
! 559: #endif
! 560: #if defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && defined(USE_V4_PKTINFO)
! 561: struct in_pktinfo pktinfo;
! 562:
! 563: if (interface->ifp != NULL) {
! 564: memset(&pktinfo, 0, sizeof (pktinfo));
! 565: pktinfo.ipi_ifindex = interface->ifp->ifr_index;
! 566: if (setsockopt(interface->wfdesc, IPPROTO_IP,
! 567: IP_PKTINFO, (char *)&pktinfo,
! 568: sizeof(pktinfo)) < 0)
! 569: log_fatal("setsockopt: IP_PKTINFO: %m");
! 570: }
! 571: #endif
! 572: result = sendto (interface -> wfdesc, (char *)raw, len, 0,
! 573: (struct sockaddr *)to, sizeof *to);
! 574: #ifdef IGNORE_HOSTUNREACH
! 575: } while (to -> sin_addr.s_addr == htonl (INADDR_BROADCAST) &&
! 576: result < 0 &&
! 577: (errno == EHOSTUNREACH ||
! 578: errno == ECONNREFUSED) &&
! 579: retry++ < 10);
! 580: #endif
! 581: if (result < 0) {
! 582: log_error ("send_packet: %m");
! 583: if (errno == ENETUNREACH)
! 584: log_error ("send_packet: please consult README file%s",
! 585: " regarding broadcast address.");
! 586: }
! 587: return result;
! 588: }
! 589:
! 590: #endif /* USE_SOCKET_SEND || USE_SOCKET_FALLBACK */
! 591:
! 592: #ifdef DHCPv6
! 593: /*
! 594: * Solaris 9 is missing the CMSG_LEN and CMSG_SPACE macros, so we will
! 595: * synthesize them (based on the BIND 9 technique).
! 596: */
! 597:
! 598: #ifndef CMSG_LEN
! 599: static size_t CMSG_LEN(size_t len) {
! 600: size_t hdrlen;
! 601: /*
! 602: * Cast NULL so that any pointer arithmetic performed by CMSG_DATA
! 603: * is correct.
! 604: */
! 605: hdrlen = (size_t)CMSG_DATA(((struct cmsghdr *)NULL));
! 606: return hdrlen + len;
! 607: }
! 608: #endif /* !CMSG_LEN */
! 609:
! 610: #ifndef CMSG_SPACE
! 611: static size_t CMSG_SPACE(size_t len) {
! 612: struct msghdr msg;
! 613: struct cmsghdr *cmsgp;
! 614:
! 615: /*
! 616: * XXX: The buffer length is an ad-hoc value, but should be enough
! 617: * in a practical sense.
! 618: */
! 619: union {
! 620: struct cmsghdr cmsg_sizer;
! 621: u_int8_t pktinfo_sizer[sizeof(struct cmsghdr) + 1024];
! 622: } dummybuf;
! 623:
! 624: memset(&msg, 0, sizeof(msg));
! 625: msg.msg_control = &dummybuf;
! 626: msg.msg_controllen = sizeof(dummybuf);
! 627:
! 628: cmsgp = (struct cmsghdr *)&dummybuf;
! 629: cmsgp->cmsg_len = CMSG_LEN(len);
! 630:
! 631: cmsgp = CMSG_NXTHDR(&msg, cmsgp);
! 632: if (cmsgp != NULL) {
! 633: return (char *)cmsgp - (char *)msg.msg_control;
! 634: } else {
! 635: return 0;
! 636: }
! 637: }
! 638: #endif /* !CMSG_SPACE */
! 639:
! 640: #endif /* DHCPv6 */
! 641:
! 642: #if defined(DHCPv6) || \
! 643: (defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && \
! 644: defined(USE_V4_PKTINFO))
! 645: /*
! 646: * For both send_packet6() and receive_packet6() we need to allocate
! 647: * space for the cmsg header information. We do this once and reuse
! 648: * the buffer. We also need the control buf for send_packet() and
! 649: * receive_packet() when we use a single socket and IP_PKTINFO to
! 650: * send the packet out the correct interface.
! 651: */
! 652: static void *control_buf = NULL;
! 653: static size_t control_buf_len = 0;
! 654:
! 655: static void
! 656: allocate_cmsg_cbuf(void) {
! 657: control_buf_len = CMSG_SPACE(sizeof(struct in6_pktinfo));
! 658: control_buf = dmalloc(control_buf_len, MDL);
! 659: return;
! 660: }
! 661: #endif /* DHCPv6, IP_PKTINFO ... */
! 662:
! 663: #ifdef DHCPv6
! 664: /*
! 665: * For both send_packet6() and receive_packet6() we need to use the
! 666: * sendmsg()/recvmsg() functions rather than the simpler send()/recv()
! 667: * functions.
! 668: *
! 669: * In the case of send_packet6(), we need to do this in order to insure
! 670: * that the reply packet leaves on the same interface that it arrived
! 671: * on.
! 672: *
! 673: * In the case of receive_packet6(), we need to do this in order to
! 674: * get the IP address the packet was sent to. This is used to identify
! 675: * whether a packet is multicast or unicast.
! 676: *
! 677: * Helpful man pages: recvmsg, readv (talks about the iovec stuff), cmsg.
! 678: *
! 679: * Also see the sections in RFC 3542 about IPV6_PKTINFO.
! 680: */
! 681:
! 682: /* Send an IPv6 packet */
! 683: ssize_t send_packet6(struct interface_info *interface,
! 684: const unsigned char *raw, size_t len,
! 685: struct sockaddr_in6 *to) {
! 686: struct msghdr m;
! 687: struct iovec v;
! 688: int result;
! 689: struct in6_pktinfo *pktinfo;
! 690: struct cmsghdr *cmsg;
! 691:
! 692: /*
! 693: * If necessary allocate space for the control message header.
! 694: * The space is common between send and receive.
! 695: */
! 696:
! 697: if (control_buf == NULL) {
! 698: allocate_cmsg_cbuf();
! 699: if (control_buf == NULL) {
! 700: log_error("send_packet6: unable to allocate cmsg header");
! 701: return(ENOMEM);
! 702: }
! 703: }
! 704: memset(control_buf, 0, control_buf_len);
! 705:
! 706: /*
! 707: * Initialize our message header structure.
! 708: */
! 709: memset(&m, 0, sizeof(m));
! 710:
! 711: /*
! 712: * Set the target address we're sending to.
! 713: */
! 714: m.msg_name = to;
! 715: m.msg_namelen = sizeof(*to);
! 716:
! 717: /*
! 718: * Set the data buffer we're sending. (Using this wacky
! 719: * "scatter-gather" stuff... we only have a single chunk
! 720: * of data to send, so we declare a single vector entry.)
! 721: */
! 722: v.iov_base = (char *)raw;
! 723: v.iov_len = len;
! 724: m.msg_iov = &v;
! 725: m.msg_iovlen = 1;
! 726:
! 727: /*
! 728: * Setting the interface is a bit more involved.
! 729: *
! 730: * We have to create a "control message", and set that to
! 731: * define the IPv6 packet information. We could set the
! 732: * source address if we wanted, but we can safely let the
! 733: * kernel decide what that should be.
! 734: */
! 735: m.msg_control = control_buf;
! 736: m.msg_controllen = control_buf_len;
! 737: cmsg = CMSG_FIRSTHDR(&m);
! 738: cmsg->cmsg_level = IPPROTO_IPV6;
! 739: cmsg->cmsg_type = IPV6_PKTINFO;
! 740: cmsg->cmsg_len = CMSG_LEN(sizeof(*pktinfo));
! 741: pktinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
! 742: memset(pktinfo, 0, sizeof(*pktinfo));
! 743: pktinfo->ipi6_ifindex = if_nametoindex(interface->name);
! 744: m.msg_controllen = cmsg->cmsg_len;
! 745:
! 746: result = sendmsg(interface->wfdesc, &m, 0);
! 747: if (result < 0) {
! 748: log_error("send_packet6: %m");
! 749: }
! 750: return result;
! 751: }
! 752: #endif /* DHCPv6 */
! 753:
! 754: #ifdef USE_SOCKET_RECEIVE
! 755: ssize_t receive_packet (interface, buf, len, from, hfrom)
! 756: struct interface_info *interface;
! 757: unsigned char *buf;
! 758: size_t len;
! 759: struct sockaddr_in *from;
! 760: struct hardware *hfrom;
! 761: {
! 762: #if !defined(USE_V4_PKTINFO)
! 763: SOCKLEN_T flen = sizeof *from;
! 764: #endif
! 765: int result;
! 766:
! 767: /*
! 768: * The normal Berkeley socket interface doesn't give us any way
! 769: * to know what hardware interface we received the message on,
! 770: * but we should at least make sure the structure is emptied.
! 771: */
! 772: memset(hfrom, 0, sizeof(*hfrom));
! 773:
! 774: #ifdef IGNORE_HOSTUNREACH
! 775: int retry = 0;
! 776: do {
! 777: #endif
! 778:
! 779: #if defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && defined(USE_V4_PKTINFO)
! 780: struct msghdr m;
! 781: struct iovec v;
! 782: struct cmsghdr *cmsg;
! 783: struct in_pktinfo *pktinfo;
! 784: unsigned int ifindex;
! 785: int found_pktinfo;
! 786:
! 787: /*
! 788: * If necessary allocate space for the control message header.
! 789: * The space is common between send and receive.
! 790: */
! 791: if (control_buf == NULL) {
! 792: allocate_cmsg_cbuf();
! 793: if (control_buf == NULL) {
! 794: log_error("receive_packet: unable to allocate cmsg "
! 795: "header");
! 796: return(ENOMEM);
! 797: }
! 798: }
! 799: memset(control_buf, 0, control_buf_len);
! 800:
! 801: /*
! 802: * Initialize our message header structure.
! 803: */
! 804: memset(&m, 0, sizeof(m));
! 805:
! 806: /*
! 807: * Point so we can get the from address.
! 808: */
! 809: m.msg_name = from;
! 810: m.msg_namelen = sizeof(*from);
! 811:
! 812: /*
! 813: * Set the data buffer we're receiving. (Using this wacky
! 814: * "scatter-gather" stuff... but we that doesn't really make
! 815: * sense for us, so we use a single vector entry.)
! 816: */
! 817: v.iov_base = buf;
! 818: v.iov_len = len;
! 819: m.msg_iov = &v;
! 820: m.msg_iovlen = 1;
! 821:
! 822: /*
! 823: * Getting the interface is a bit more involved.
! 824: *
! 825: * We set up some space for a "control message". We have
! 826: * previously asked the kernel to give us packet
! 827: * information (when we initialized the interface), so we
! 828: * should get the destination address from that.
! 829: */
! 830: m.msg_control = control_buf;
! 831: m.msg_controllen = control_buf_len;
! 832:
! 833: result = recvmsg(interface->rfdesc, &m, 0);
! 834:
! 835: if (result >= 0) {
! 836: /*
! 837: * If we did read successfully, then we need to loop
! 838: * through the control messages we received and
! 839: * find the one with our destination address.
! 840: *
! 841: * We also keep a flag to see if we found it. If we
! 842: * didn't, then we consider this to be an error.
! 843: */
! 844: found_pktinfo = 0;
! 845: cmsg = CMSG_FIRSTHDR(&m);
! 846: while (cmsg != NULL) {
! 847: if ((cmsg->cmsg_level == IPPROTO_IP) &&
! 848: (cmsg->cmsg_type == IP_PKTINFO)) {
! 849: pktinfo = (struct in_pktinfo *)CMSG_DATA(cmsg);
! 850: ifindex = pktinfo->ipi_ifindex;
! 851: /*
! 852: * We pass the ifindex back to the caller
! 853: * using the unused hfrom parameter avoiding
! 854: * interface changes between sockets and
! 855: * the discover code.
! 856: */
! 857: memcpy(hfrom->hbuf, &ifindex, sizeof(ifindex));
! 858: found_pktinfo = 1;
! 859: }
! 860: cmsg = CMSG_NXTHDR(&m, cmsg);
! 861: }
! 862: if (!found_pktinfo) {
! 863: result = -1;
! 864: errno = EIO;
! 865: }
! 866: }
! 867: #else
! 868: result = recvfrom (interface -> rfdesc, (char *)buf, len, 0,
! 869: (struct sockaddr *)from, &flen);
! 870: #endif /* IP_PKTINFO ... */
! 871: #ifdef IGNORE_HOSTUNREACH
! 872: } while (result < 0 &&
! 873: (errno == EHOSTUNREACH ||
! 874: errno == ECONNREFUSED) &&
! 875: retry++ < 10);
! 876: #endif
! 877: return result;
! 878: }
! 879:
! 880: #endif /* USE_SOCKET_RECEIVE */
! 881:
! 882: #ifdef DHCPv6
! 883: ssize_t
! 884: receive_packet6(struct interface_info *interface,
! 885: unsigned char *buf, size_t len,
! 886: struct sockaddr_in6 *from, struct in6_addr *to_addr,
! 887: unsigned int *if_idx)
! 888: {
! 889: struct msghdr m;
! 890: struct iovec v;
! 891: int result;
! 892: struct cmsghdr *cmsg;
! 893: struct in6_pktinfo *pktinfo;
! 894: int found_pktinfo;
! 895:
! 896: /*
! 897: * If necessary allocate space for the control message header.
! 898: * The space is common between send and receive.
! 899: */
! 900: if (control_buf == NULL) {
! 901: allocate_cmsg_cbuf();
! 902: if (control_buf == NULL) {
! 903: log_error("receive_packet6: unable to allocate cmsg "
! 904: "header");
! 905: return(ENOMEM);
! 906: }
! 907: }
! 908: memset(control_buf, 0, control_buf_len);
! 909:
! 910: /*
! 911: * Initialize our message header structure.
! 912: */
! 913: memset(&m, 0, sizeof(m));
! 914:
! 915: /*
! 916: * Point so we can get the from address.
! 917: */
! 918: m.msg_name = from;
! 919: m.msg_namelen = sizeof(*from);
! 920:
! 921: /*
! 922: * Set the data buffer we're receiving. (Using this wacky
! 923: * "scatter-gather" stuff... but we that doesn't really make
! 924: * sense for us, so we use a single vector entry.)
! 925: */
! 926: v.iov_base = buf;
! 927: v.iov_len = len;
! 928: m.msg_iov = &v;
! 929: m.msg_iovlen = 1;
! 930:
! 931: /*
! 932: * Getting the interface is a bit more involved.
! 933: *
! 934: * We set up some space for a "control message". We have
! 935: * previously asked the kernel to give us packet
! 936: * information (when we initialized the interface), so we
! 937: * should get the destination address from that.
! 938: */
! 939: m.msg_control = control_buf;
! 940: m.msg_controllen = control_buf_len;
! 941:
! 942: result = recvmsg(interface->rfdesc, &m, 0);
! 943:
! 944: if (result >= 0) {
! 945: /*
! 946: * If we did read successfully, then we need to loop
! 947: * through the control messages we received and
! 948: * find the one with our destination address.
! 949: *
! 950: * We also keep a flag to see if we found it. If we
! 951: * didn't, then we consider this to be an error.
! 952: */
! 953: found_pktinfo = 0;
! 954: cmsg = CMSG_FIRSTHDR(&m);
! 955: while (cmsg != NULL) {
! 956: if ((cmsg->cmsg_level == IPPROTO_IPV6) &&
! 957: (cmsg->cmsg_type == IPV6_PKTINFO)) {
! 958: pktinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
! 959: *to_addr = pktinfo->ipi6_addr;
! 960: *if_idx = pktinfo->ipi6_ifindex;
! 961: found_pktinfo = 1;
! 962: }
! 963: cmsg = CMSG_NXTHDR(&m, cmsg);
! 964: }
! 965: if (!found_pktinfo) {
! 966: result = -1;
! 967: errno = EIO;
! 968: }
! 969: }
! 970:
! 971: return result;
! 972: }
! 973: #endif /* DHCPv6 */
! 974:
! 975: #if defined (USE_SOCKET_FALLBACK)
! 976: /* This just reads in a packet and silently discards it. */
! 977:
! 978: isc_result_t fallback_discard (object)
! 979: omapi_object_t *object;
! 980: {
! 981: char buf [1540];
! 982: struct sockaddr_in from;
! 983: SOCKLEN_T flen = sizeof from;
! 984: int status;
! 985: struct interface_info *interface;
! 986:
! 987: if (object -> type != dhcp_type_interface)
! 988: return ISC_R_INVALIDARG;
! 989: interface = (struct interface_info *)object;
! 990:
! 991: status = recvfrom (interface -> wfdesc, buf, sizeof buf, 0,
! 992: (struct sockaddr *)&from, &flen);
! 993: #if defined (DEBUG)
! 994: /* Only report fallback discard errors if we're debugging. */
! 995: if (status < 0) {
! 996: log_error ("fallback_discard: %m");
! 997: return ISC_R_UNEXPECTED;
! 998: }
! 999: #endif
! 1000: return ISC_R_SUCCESS;
! 1001: }
! 1002: #endif /* USE_SOCKET_FALLBACK */
! 1003:
! 1004: #if defined (USE_SOCKET_SEND)
! 1005: int can_unicast_without_arp (ip)
! 1006: struct interface_info *ip;
! 1007: {
! 1008: return 0;
! 1009: }
! 1010:
! 1011: int can_receive_unicast_unconfigured (ip)
! 1012: struct interface_info *ip;
! 1013: {
! 1014: #if defined (SOCKET_CAN_RECEIVE_UNICAST_UNCONFIGURED)
! 1015: return 1;
! 1016: #else
! 1017: return 0;
! 1018: #endif
! 1019: }
! 1020:
! 1021: int supports_multiple_interfaces (ip)
! 1022: struct interface_info *ip;
! 1023: {
! 1024: #if defined(SO_BINDTODEVICE) || \
! 1025: (defined(IP_PKTINFO) && defined(IP_RECVPKTINFO) && \
! 1026: defined(USE_V4_PKTINFO))
! 1027: return(1);
! 1028: #else
! 1029: return(0);
! 1030: #endif
! 1031: }
! 1032:
! 1033: /* If we have SO_BINDTODEVICE, set up a fallback interface; otherwise,
! 1034: do not. */
! 1035:
! 1036: void maybe_setup_fallback ()
! 1037: {
! 1038: #if defined (USE_SOCKET_FALLBACK)
! 1039: isc_result_t status;
! 1040: struct interface_info *fbi = (struct interface_info *)0;
! 1041: if (setup_fallback (&fbi, MDL)) {
! 1042: fbi -> wfdesc = if_register_socket (fbi, AF_INET, 0);
! 1043: fbi -> rfdesc = fbi -> wfdesc;
! 1044: log_info ("Sending on Socket/%s%s%s",
! 1045: fbi -> name,
! 1046: (fbi -> shared_network ? "/" : ""),
! 1047: (fbi -> shared_network ?
! 1048: fbi -> shared_network -> name : ""));
! 1049:
! 1050: status = omapi_register_io_object ((omapi_object_t *)fbi,
! 1051: if_readsocket, 0,
! 1052: fallback_discard, 0, 0);
! 1053: if (status != ISC_R_SUCCESS)
! 1054: log_fatal ("Can't register I/O handle for %s: %s",
! 1055: fbi -> name, isc_result_totext (status));
! 1056: interface_dereference (&fbi, MDL);
! 1057: }
! 1058: #endif
! 1059: }
! 1060:
! 1061:
! 1062: #if defined(sun) && defined(USE_V4_PKTINFO)
! 1063: /* This code assumes the existence of SIOCGLIFHWADDR */
! 1064: void
! 1065: get_hw_addr(const char *name, struct hardware *hw) {
! 1066: struct sockaddr_dl *dladdrp;
! 1067: int rv, sock, i;
! 1068: struct lifreq lifr;
! 1069:
! 1070: memset(&lifr, 0, sizeof (lifr));
! 1071: (void) strlcpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
! 1072: /*
! 1073: * Check if the interface is a virtual or IPMP interface - in those
! 1074: * cases it has no hw address, so generate a random one.
! 1075: */
! 1076: if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ||
! 1077: ioctl(sock, SIOCGLIFFLAGS, &lifr) < 0) {
! 1078: if (sock != -1)
! 1079: (void) close(sock);
! 1080:
! 1081: #ifdef DHCPv6
! 1082: /*
! 1083: * If approrpriate try this with an IPv6 socket
! 1084: */
! 1085: if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) >= 0 &&
! 1086: ioctl(sock, SIOCGLIFFLAGS, &lifr) >= 0) {
! 1087: goto flag_check;
! 1088: }
! 1089: if (sock != -1)
! 1090: (void) close(sock);
! 1091: #endif
! 1092: log_fatal("Couldn't get interface flags for %s: %m", name);
! 1093:
! 1094: }
! 1095:
! 1096: flag_check:
! 1097: if (lifr.lifr_flags & (IFF_VIRTUAL|IFF_IPMP)) {
! 1098: hw->hlen = sizeof (hw->hbuf);
! 1099: srandom((long)gethrtime());
! 1100:
! 1101: for (i = 0; i < hw->hlen; ++i) {
! 1102: hw->hbuf[i] = random() % 256;
! 1103: }
! 1104:
! 1105: if (sock != -1)
! 1106: (void) close(sock);
! 1107: return;
! 1108: }
! 1109:
! 1110: if (ioctl(sock, SIOCGLIFHWADDR, &lifr) < 0)
! 1111: log_fatal("Couldn't get interface hardware address for %s: %m",
! 1112: name);
! 1113: dladdrp = (struct sockaddr_dl *)&lifr.lifr_addr;
! 1114: hw->hlen = dladdrp->sdl_alen;
! 1115: memcpy(hw->hbuf, LLADDR(dladdrp), hw->hlen);
! 1116:
! 1117: if (sock != -1)
! 1118: (void) close(sock);
! 1119: }
! 1120: #endif /* defined(sun) */
! 1121:
! 1122: #endif /* USE_SOCKET_SEND */
! 1123:
! 1124: /*
! 1125: * Code to set a handler for signals. This
! 1126: * exists to allow us to ignore SIGPIPE signals
! 1127: * but could be used for other purposes in the
! 1128: * future.
! 1129: */
! 1130:
! 1131: isc_result_t
! 1132: dhcp_handle_signal(int sig, void (*handler)(int)) {
! 1133: struct sigaction sa;
! 1134:
! 1135: memset(&sa, 0, sizeof(sa));
! 1136: sa.sa_handler = handler;
! 1137:
! 1138: if (sigfillset(&sa.sa_mask) != 0 ||
! 1139: sigaction(sig, &sa, NULL) < 0) {
! 1140: log_error("Unable to set up signal handler for %d, %m", sig);
! 1141: return (ISC_R_UNEXPECTED);
! 1142: }
! 1143:
! 1144: return (ISC_R_SUCCESS);
! 1145: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to socket.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / common