efcb75cdb97260a12b2feea32949c83c1a873624
[nfs-utils.git] / 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 */