support/export/hostname.c

   1 /*
   2  * Copyright 2010 Oracle.  All rights reserved.
   3  *
   4  * This file is part of nfs-utils.
   5  *
   6  * nfs-utils is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * nfs-utils is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with nfs-utils.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <arpa/inet.h>
  27 #include <netdb.h>
  28 #include <errno.h>
  29
  30 #include "sockaddr.h"
  31 #include "exportfs.h"
  32
  33 /**
  34  * host_ntop - generate presentation address given a sockaddr
  35  * @sap: pointer to socket address
  36  * @buf: working storage
  37  * @buflen: size of @buf in bytes
  38  *
  39  * Returns a pointer to a @buf.
  40  */
  41 #ifdef HAVE_GETNAMEINFO
  42 char *
  43 host_ntop(const struct sockaddr *sap, char *buf, const size_t buflen)
  44 {
  45         socklen_t salen = nfs_sockaddr_length(sap);
  46         int error;
  47
  48         memset(buf, 0, buflen);
  49
  50         if (salen == 0) {
  51                 (void)strncpy(buf, "bad family", buflen - 1);
  52                 return buf;
  53         }
  54
  55         error = getnameinfo(sap, salen, buf, (socklen_t)buflen,
  56                                                 NULL, 0, NI_NUMERICHOST);
  57         if (error != 0) {
  58                 buf[0] = '\0';
  59                 (void)strncpy(buf, "bad address", buflen - 1);
  60         }
  61
  62         return buf;
  63 }
  64 #else   /* !HAVE_GETNAMEINFO */
  65 char *
  66 host_ntop(const struct sockaddr *sap, char *buf, const size_t buflen)
  67 {
  68         const struct sockaddr_in *sin = (const struct sockaddr_in *)(char *)sap;
  69
  70         memset(buf, 0, buflen);
  71
  72         if (sin->sin_family != AF_INET)
  73                 (void)strncpy(buf, "bad family", buflen - 1);
  74                 return buf;
  75         }
  76
  77         if (inet_ntop(AF_INET, &sin->sin_addr.s_addr, buf, buflen) != NULL)
  78                 return buf;
  79
  80         buf[0] = '\0';
  81         (void)strncpy(buf, "bad address", buflen - 1);
  82         return buf;
  83 }
  84 #endif  /* !HAVE_GETNAMEINFO */
  85
  86 /**
  87  * host_pton - return addrinfo for a given presentation address
  88  * @paddr: pointer to a '\0'-terminated ASCII string containing an
  89  *              IP presentation address
  90  *
  91  * Returns address info structure, or NULL if an error occurs.  Caller
  92  * must free the returned structure with freeaddrinfo(3).
  93  */
  94 __attribute_malloc__
  95 struct addrinfo *
  96 host_pton(const char *paddr)
  97 {
  98         struct addrinfo *ai = NULL;
  99         struct addrinfo hint = {
 100                 /* don't return duplicates */
 101                 .ai_protocol    = (int)IPPROTO_UDP,
 102                 .ai_flags       = AI_NUMERICHOST,
 103                 .ai_family      = AF_UNSPEC,
 104         };
 105         struct sockaddr_in sin;
 106         int error, inet4;
 107
 108         /*
 109          * Although getaddrinfo(3) is easier to use and supports
 110          * IPv6, it recognizes incomplete addresses like "10.4"
 111          * as valid AF_INET addresses.  It also accepts presentation
 112          * addresses that end with a blank.
 113          *
 114          * inet_pton(3) is much stricter.  Use it to be certain we
 115          * have a real AF_INET presentation address, before invoking
 116          * getaddrinfo(3) to generate the full addrinfo list.
 117          */
 118         inet4 = 1;
 119         if (inet_pton(AF_INET, paddr, &sin.sin_addr) == 0)
 120                 inet4 = 0;
 121
 122         error = getaddrinfo(paddr, NULL, &hint, &ai);
 123         switch (error) {
 124         case 0:
 125                 if (!inet4 && ai->ai_addr->sa_family == AF_INET) {
 126                         freeaddrinfo(ai);
 127                         break;
 128                 }
 129                 return ai;
 130         case EAI_NONAME:
 131                 if (paddr == NULL)
 132                         xlog(D_GENERAL, "%s: passed a NULL presentation address",
 133                                 __func__);
 134                 break;
 135         case EAI_SYSTEM:
 136                 xlog(D_GENERAL, "%s: failed to convert %s: (%d) %m",
 137                                 __func__, paddr, errno);
 138                 break;
 139         default:
 140                 xlog(D_GENERAL, "%s: failed to convert %s: %s",
 141                                 __func__, paddr, gai_strerror(error));
 142                 break;
 143         }
 144
 145         return NULL;
 146 }
 147
 148 /**
 149  * host_addrinfo - return addrinfo for a given hostname
 150  * @hostname: pointer to a '\0'-terminated ASCII string containing a hostname
 151  *
 152  * Returns address info structure with ai_canonname filled in, or NULL
 153  * if no information is available for @hostname.  Caller must free the
 154  * returned structure with freeaddrinfo(3).
 155  */
 156 __attribute_malloc__
 157 struct addrinfo *
 158 host_addrinfo(const char *hostname)
 159 {
 160         struct addrinfo *ai = NULL;
 161         struct addrinfo hint = {
 162 #ifdef IPV6_SUPPORTED
 163                 .ai_family      = AF_UNSPEC,
 164 #else
 165                 .ai_family      = AF_INET,
 166 #endif
 167                 /* don't return duplicates */
 168                 .ai_protocol    = (int)IPPROTO_UDP,
 169                 .ai_flags       = AI_CANONNAME,
 170         };
 171         int error;
 172
 173         error = getaddrinfo(hostname, NULL, &hint, &ai);
 174         switch (error) {
 175         case 0:
 176                 return ai;
 177         case EAI_SYSTEM:
 178                 xlog(D_GENERAL, "%s: failed to resolve %s: (%d) %m",
 179                                 __func__, hostname, errno);
 180                 break;
 181         default:
 182                 xlog(D_GENERAL, "%s: failed to resolve %s: %s",
 183                                 __func__, hostname, gai_strerror(error));
 184                 break;
 185         }
 186
 187         return NULL;
 188 }
 189
 190 /**
 191  * host_canonname - return canonical hostname bound to an address
 192  * @sap: pointer to socket address to look up
 193  *
 194  * Discover the canonical hostname associated with the given socket
 195  * address.  The host's reverse mapping is verified in the process.
 196  *
 197  * Returns a '\0'-terminated ASCII string containing a hostname, or
 198  * NULL if no hostname can be found for @sap.  Caller must free
 199  * the string.
 200  */
 201 #ifdef HAVE_GETNAMEINFO
 202 __attribute_malloc__
 203 char *
 204 host_canonname(const struct sockaddr *sap)
 205 {
 206         socklen_t salen = nfs_sockaddr_length(sap);
 207         char buf[NI_MAXHOST];
 208         int error;
 209
 210         if (salen == 0) {
 211                 xlog(D_GENERAL, "%s: unsupported address family %d",
 212                                 __func__, sap->sa_family);
 213                 return NULL;
 214         }
 215
 216         memset(buf, 0, sizeof(buf));
 217         error = getnameinfo(sap, salen, buf, (socklen_t)sizeof(buf),
 218                                                         NULL, 0, NI_NAMEREQD);
 219         switch (error) {
 220         case 0:
 221                 break;
 222         case EAI_SYSTEM:
 223                 xlog(D_GENERAL, "%s: getnameinfo(3) failed: (%d) %m",
 224                                 __func__, errno);
 225                 return NULL;
 226         default:
 227                 (void)getnameinfo(sap, salen, buf, (socklen_t)sizeof(buf),
 228                                                         NULL, 0, NI_NUMERICHOST);
 229                 xlog(D_GENERAL, "%s: failed to resolve %s: %s",
 230                                 __func__, buf, gai_strerror(error));
 231                 return NULL;
 232         }
 233
 234         return strdup(buf);
 235 }
 236 #else   /* !HAVE_GETNAMEINFO */
 237 __attribute_malloc__
 238 char *
 239 host_canonname(const struct sockaddr *sap)
 240 {
 241         const struct sockaddr_in *sin = (const struct sockaddr_in *)(char *)sap;
 242         const struct in_addr *addr = &sin->sin_addr;
 243         struct hostent *hp;
 244
 245         if (sap->sa_family != AF_INET)
 246                 return NULL;
 247
 248         hp = gethostbyaddr(addr, (socklen_t)sizeof(addr), AF_INET);
 249         if (hp == NULL)
 250                 return NULL;
 251
 252         return strdup(hp->h_name);
 253 }
 254 #endif  /* !HAVE_GETNAMEINFO */
 255
 256 /**
 257  * host_reliable_addrinfo - return addrinfo for a given address
 258  * @sap: pointer to socket address to look up
 259  *
 260  * Reverse and forward lookups are performed to ensure the address has
 261  * proper forward and reverse mappings.
 262  *
 263  * Returns address info structure with ai_canonname filled in, or NULL
 264  * if no information is available for @sap.  Caller must free the returned
 265  * structure with freeaddrinfo(3).
 266  */
 267 __attribute_malloc__
 268 struct addrinfo *
 269 host_reliable_addrinfo(const struct sockaddr *sap)
 270 {
 271         struct addrinfo *ai;
 272         char *hostname;
 273
 274         hostname = host_canonname(sap);
 275         if (hostname == NULL)
 276                 return NULL;
 277
 278         ai = host_addrinfo(hostname);
 279
 280         free(hostname);
 281         return ai;
 282 }
 283
 284 /**
 285  * host_numeric_addrinfo - return addrinfo without doing DNS queries
 286  * @sap: pointer to socket address
 287  *
 288  * Returns address info structure, or NULL if an error occurred.
 289  * Caller must free the returned structure with freeaddrinfo(3).
 290  */
 291 #ifdef HAVE_GETNAMEINFO
 292 __attribute_malloc__
 293 struct addrinfo *
 294 host_numeric_addrinfo(const struct sockaddr *sap)
 295 {
 296         socklen_t salen = nfs_sockaddr_length(sap);
 297         char buf[INET6_ADDRSTRLEN];
 298         struct addrinfo *ai;
 299         int error;
 300
 301         if (salen == 0) {
 302                 xlog(D_GENERAL, "%s: unsupported address family %d",
 303                                 __func__, sap->sa_family);
 304                 return NULL;
 305         }
 306
 307         memset(buf, 0, sizeof(buf));
 308         error = getnameinfo(sap, salen, buf, (socklen_t)sizeof(buf),
 309                                                 NULL, 0, NI_NUMERICHOST);
 310         switch (error) {
 311         case 0:
 312                 break;
 313         case EAI_SYSTEM:
 314                 xlog(D_GENERAL, "%s: getnameinfo(3) failed: (%d) %m",
 315                                 __func__, errno);
 316                 return NULL;
 317         default:
 318                 xlog(D_GENERAL, "%s: getnameinfo(3) failed: %s",
 319                                 __func__, gai_strerror(error));
 320                 return NULL;
 321         }
 322
 323         ai = host_pton(buf);
 324
 325         /*
 326          * getaddrinfo(AI_NUMERICHOST) never fills in ai_canonname
 327          */
 328         if (ai != NULL) {
 329                 free(ai->ai_canonname);         /* just in case */
 330                 ai->ai_canonname = strdup(buf);
 331                 if (ai->ai_canonname == NULL) {
 332                         freeaddrinfo(ai);
 333                         ai = NULL;
 334                 }
 335         }
 336
 337         return ai;
 338 }
 339 #else   /* !HAVE_GETNAMEINFO */
 340 __attribute_malloc__
 341 struct addrinfo *
 342 host_numeric_addrinfo(const struct sockaddr *sap)
 343 {
 344         const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
 345         const struct in_addr *addr = &sin->sin_addr;
 346         char buf[INET_ADDRSTRLEN];
 347         struct addrinfo *ai;
 348
 349         if (sap->sa_family != AF_INET)
 350                 return NULL;
 351
 352         memset(buf, 0, sizeof(buf));
 353         if (inet_ntop(AF_INET, (char *)addr, buf,
 354                                         (socklen_t)sizeof(buf)) == NULL)
 355                 return NULL;
 356
 357         ai = host_pton(buf);
 358
 359         /*
 360          * getaddrinfo(AI_NUMERICHOST) never fills in ai_canonname
 361          */
 362         if (ai != NULL) {
 363                 ai->ai_canonname = strdup(buf);
 364                 if (ai->ai_canonname == NULL) {
 365                         freeaddrinfo(ai);
 366                         ai = NULL;
 367                 }
 368         }
 369
 370         return ai;
 371 }
 372 #endif  /* !HAVE_GETNAMEINFO */