tftpd/recvfrom.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2001-2006 H. Peter Anvin - All Rights Reserved
   4  *
   5  *   This program is free software available under the same license
   6  *   as the "OpenBSD" operating system, distributed at
   7  *   http://www.openbsd.org/.
   8  *
   9  * ----------------------------------------------------------------------- */
  10
  11 /*
  12  * recvfrom.c
  13  *
  14  * Emulate recvfrom() using recvmsg(), but try to capture the local address
  15  * since some TFTP clients consider it an error to get the reply from another
  16  * IP address than the request was sent to.
  17  *
  18  */
  19
  20 #include "config.h"             /* Must be included first! */
  21 #include "common/tftpsubs.h"
  22 #include "recvfrom.h"
  23 #ifdef HAVE_MACHINE_PARAM_H
  24 #include <machine/param.h>      /* Needed on some versions of FreeBSD */
  25 #endif
  26
  27 #if defined(HAVE_RECVMSG) && defined(HAVE_MSGHDR_MSG_CONTROL)
  28
  29 #include <sys/uio.h>
  30
  31 #ifdef IP_PKTINFO
  32 # ifndef HAVE_STRUCT_IN_PKTINFO
  33 #  ifdef __linux__
  34 /* Assume this version of glibc simply lacks the definition */
  35 struct in_pktinfo {
  36     int ipi_ifindex;
  37     struct in_addr ipi_spec_dst;
  38     struct in_addr ipi_addr;
  39 };
  40 #  else
  41 #   undef IP_PKTINFO            /* No definition, no way to get it */
  42 #  endif
  43 # endif
  44 #endif
  45
  46 #ifndef CMSG_LEN
  47 # define CMSG_LEN(size)  (sizeof(struct cmsghdr) + (size))
  48 #endif
  49 #ifndef CMSG_SPACE
  50 # define CMSG_SPACE(size) (sizeof(struct cmsghdr) + (size))
  51 #endif
  52
  53 /*
  54  * Check to see if this is a valid local address, meaning that we can
  55  * legally bind to it.
  56  */
  57 static int address_is_local(const union sock_addr *addr)
  58 {
  59     union sock_addr sa1, sa2;
  60     int sockfd = -1;
  61     int e;
  62     int rv = 0;
  63     socklen_t addrlen;
  64
  65     memcpy(&sa1, addr, sizeof sa1);
  66
  67     /* Multicast or universal broadcast address? */
  68     if (sa1.sa.sa_family == AF_INET) {
  69         if (ntohl(sa1.si.sin_addr.s_addr) >= (224UL << 24))
  70             return 0;
  71         sa1.si.sin_port = 0;    /* Any port */
  72     }
  73 #ifdef HAVE_IPV6
  74     else if (sa1.sa.sa_family == AF_INET6) {
  75         if (IN6_IS_ADDR_MULTICAST(&sa1.s6.sin6_addr))
  76             return 0;
  77         sa1.s6.sin6_port = 0;   /* Any port */
  78     }
  79 #endif
  80     else
  81         return 0;
  82
  83     sockfd = socket(sa1.sa.sa_family, SOCK_DGRAM, 0);
  84     if (sockfd < 0)
  85         goto err;
  86
  87     if (bind(sockfd, &sa1.sa, SOCKLEN(&sa1)))
  88         goto err;
  89
  90     addrlen = SOCKLEN(addr);
  91     if (getsockname(sockfd, (struct sockaddr *)&sa2, &addrlen))
  92         goto err;
  93
  94     if (sa1.sa.sa_family != sa2.sa.sa_family)
  95         goto err;
  96
  97     if (sa2.sa.sa_family == AF_INET)
  98         rv = sa1.si.sin_addr.s_addr == sa2.si.sin_addr.s_addr;
  99 #ifdef HAVE_IPV6
 100     else if (sa2.sa.sa_family == AF_INET6)
 101         rv = IN6_ARE_ADDR_EQUAL(&sa1.s6.sin6_addr, &sa2.s6.sin6_addr);
 102 #endif
 103     else
 104         rv = 0;
 105
 106 err:
 107     e = errno;
 108
 109     if (sockfd >= 0)
 110         close(sockfd);
 111
 112     errno = e;
 113     return rv;
 114 }
 115
 116 static void normalize_ip6_compat(union sock_addr *myaddr)
 117 {
 118 #ifdef HAVE_IPV6
 119     static const uint8_t ip6_compat_prefix[12] =
 120         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
 121     struct sockaddr_in in;
 122
 123     if (myaddr->sa.sa_family == AF_INET6 &&
 124         !memcmp(&myaddr->s6.sin6_addr, ip6_compat_prefix,
 125                 sizeof ip6_compat_prefix)) {
 126         bzero(&in, sizeof in);
 127         in.sin_family = AF_INET;
 128         in.sin_port = myaddr->s6.sin6_port;
 129         memcpy(&in.sin_addr, (const char *)&myaddr->s6.sin6_addr +
 130                sizeof ip6_compat_prefix, sizeof in.sin_addr);
 131         memcpy(&myaddr->si, &in, sizeof in);
 132     }
 133 #else
 134     (void)myaddr;
 135 #endif
 136 }
 137
 138 int
 139 myrecvfrom(int s, void *buf, int len, unsigned int flags,
 140            union sock_addr *from, union sock_addr *myaddr)
 141 {
 142     struct msghdr msg;
 143     struct iovec iov;
 144     int n;
 145     struct cmsghdr *cmptr;
 146     union {
 147         struct cmsghdr cm;
 148 #ifdef IP_PKTINFO
 149         char control[CMSG_SPACE(sizeof(struct in_addr)) +
 150                      CMSG_SPACE(sizeof(struct in_pktinfo))];
 151 #else
 152         char control[CMSG_SPACE(sizeof(struct in_addr))];
 153 #endif
 154 #ifdef HAVE_IPV6
 155 #ifdef HAVE_STRUCT_IN6_PKTINFO
 156         char control6[CMSG_SPACE(sizeof(struct in6_addr)) +
 157                      CMSG_SPACE(sizeof(struct in6_pktinfo))];
 158 #else
 159         char control6[CMSG_SPACE(sizeof(struct in6_addr))];
 160 #endif
 161 #endif
 162     } control_un;
 163     int on = 1;
 164 #ifdef IP_PKTINFO
 165     struct in_pktinfo pktinfo;
 166 #endif
 167 #ifdef HAVE_STRUCT_IN6_PKTINFO
 168     struct in6_pktinfo pktinfo6;
 169 #endif
 170
 171     /* Try to enable getting the return address */
 172 #ifdef IP_RECVDSTADDR
 173     if (from->sa.sa_family == AF_INET)
 174         setsockopt(s, IPPROTO_IP, IP_RECVDSTADDR, &on, sizeof(on));
 175 #endif
 176 #ifdef IP_PKTINFO
 177     if (from->sa.sa_family == AF_INET)
 178         setsockopt(s, IPPROTO_IP, IP_PKTINFO, &on, sizeof(on));
 179 #endif
 180 #ifdef HAVE_IPV6
 181 #ifdef IPV6_RECVPKTINFO
 182     if (from->sa.sa_family == AF_INET6)
 183         setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on));
 184 #endif
 185 #endif
 186     bzero(&msg, sizeof msg);    /* Clear possible system-dependent fields */
 187     msg.msg_control = control_un.control;
 188     msg.msg_controllen = sizeof(control_un);
 189     msg.msg_flags = 0;
 190
 191     msg.msg_name = &from->sa;
 192     msg.msg_namelen = sizeof(*from);
 193     iov.iov_base = buf;
 194     iov.iov_len = len;
 195     msg.msg_iov = &iov;
 196     msg.msg_iovlen = 1;
 197
 198     if ((n = recvmsg(s, &msg, flags)) < 0)
 199         return n;               /* Error */
 200
 201     if (myaddr) {
 202         bzero(myaddr, sizeof(*myaddr));
 203         myaddr->sa.sa_family = from->sa.sa_family;
 204
 205         if (msg.msg_controllen < sizeof(struct cmsghdr) ||
 206             (msg.msg_flags & MSG_CTRUNC))
 207             return n;           /* No information available */
 208
 209         for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL;
 210              cmptr = CMSG_NXTHDR(&msg, cmptr)) {
 211
 212             if (from->sa.sa_family == AF_INET) {
 213                 myaddr->sa.sa_family = AF_INET;
 214 #ifdef IP_RECVDSTADDR
 215                 if (cmptr->cmsg_level == IPPROTO_IP &&
 216                     cmptr->cmsg_type == IP_RECVDSTADDR) {
 217                     memcpy(&myaddr->si.sin_addr, CMSG_DATA(cmptr),
 218                            sizeof(struct in_addr));
 219                 }
 220 #endif
 221
 222 #ifdef IP_PKTINFO
 223                 if (cmptr->cmsg_level == IPPROTO_IP &&
 224                     cmptr->cmsg_type == IP_PKTINFO) {
 225                     memcpy(&pktinfo, CMSG_DATA(cmptr),
 226                            sizeof(struct in_pktinfo));
 227                     memcpy(&myaddr->si.sin_addr, &pktinfo.ipi_addr,
 228                            sizeof(struct in_addr));
 229                 }
 230 #endif
 231             }
 232 #ifdef HAVE_IPV6
 233             else if (from->sa.sa_family == AF_INET6) {
 234                 myaddr->sa.sa_family = AF_INET6;
 235 #ifdef IP6_RECVDSTADDR
 236                 if (cmptr->cmsg_level == IPPROTO_IPV6 &&
 237                     cmptr->cmsg_type == IPV6_RECVDSTADDR )
 238                     memcpy(&myaddr->s6.sin6_addr, CMSG_DATA(cmptr),
 239                            sizeof(struct in6_addr));
 240 #endif
 241
 242 #ifdef HAVE_STRUCT_IN6_PKTINFO
 243                 if (cmptr->cmsg_level == IPPROTO_IPV6 &&
 244                     (
 245 #ifdef IPV6_RECVPKTINFO
 246                      cmptr->cmsg_type == IPV6_RECVPKTINFO ||
 247 #endif
 248                      cmptr->cmsg_type == IPV6_PKTINFO)) {
 249                     memcpy(&pktinfo6, CMSG_DATA(cmptr),
 250                            sizeof(struct in6_pktinfo));
 251                     memcpy(&myaddr->s6.sin6_addr, &pktinfo6.ipi6_addr,
 252                            sizeof(struct in6_addr));
 253                 }
 254 #endif
 255             }
 256 #endif
 257         }
 258
 259         normalize_ip6_compat(myaddr);
 260
 261         /* If the address is not a valid local address,
 262          * then bind to any address...
 263          */
 264         if (address_is_local(myaddr) != 1) {
 265             if (myaddr->sa.sa_family == AF_INET)
 266                 ((struct sockaddr_in *)myaddr)->sin_addr.s_addr = INADDR_ANY;
 267 #ifdef HAVE_IPV6
 268             else if (myaddr->sa.sa_family == AF_INET6)
 269                 memset(&myaddr->s6.sin6_addr, 0, sizeof(struct in6_addr));
 270 #endif
 271         }
 272     }
 273
 274     normalize_ip6_compat(from);
 275
 276     return n;
 277 }
 278
 279 #else                           /* pointless... */
 280
 281 int
 282 myrecvfrom(int s, void *buf, int len, unsigned int flags,
 283            union sock_addr *from, union sock_addr *myaddr)
 284 {
 285     /* There is no way we can get the local address, fudge it */
 286     socklen_t fromlen = sizeof(*from);
 287
 288     bzero(myaddr, sizeof(*myaddr));
 289     myaddr->sa.sa_family = from->sa.sa_family;
 290     sa_set_port(myaddr, htons(IPPORT_TFTP));
 291
 292     return recvfrom(s, buf, len, flags, &from->sa, &fromlen);
 293 }
 294
 295 #endif