38f22650c61e50f3447ba4aebf64b57936584325
[nfs-utils.git] / utils / statd / hostname.c
1 /*
2  * Copyright 2009 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 /*
21  * NSM for Linux.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <sys/types.h>
29 #include <sys/socket.h>
30
31 #include <stdlib.h>
32 #include <stdbool.h>
33 #include <string.h>
34 #include <strings.h>
35 #include <netdb.h>
36 #include <arpa/inet.h>
37
38 #include "sockaddr.h"
39 #include "statd.h"
40 #include "xlog.h"
41
42 #ifndef HAVE_DECL_AI_ADDRCONFIG
43 #define AI_ADDRCONFIG   0
44 #endif
45
46 /**
47  * statd_present_address - convert sockaddr to presentation address
48  * @sap: pointer to socket address to convert
49  * @buf: pointer to buffer to fill in
50  * @buflen: length of buffer
51  *
52  * Convert the passed-in sockaddr-style address to presentation format.
53  * The presentation format address is placed in @buf and is
54  * '\0'-terminated.
55  *
56  * Returns true if successful; otherwise false.
57  *
58  * getnameinfo(3) is preferred, since it can parse IPv6 scope IDs.
59  * An alternate version of statd_present_address() is available to
60  * handle older glibcs that do not have getnameinfo(3).
61  */
62 #ifdef HAVE_GETNAMEINFO
63 _Bool
64 statd_present_address(const struct sockaddr *sap, char *buf, const size_t buflen)
65 {
66         socklen_t salen;
67         int error;
68
69         salen = nfs_sockaddr_length(sap);
70         if (salen == 0) {
71                 xlog(D_GENERAL, "%s: unsupported address family",
72                                 __func__);
73                 return false;
74         }
75
76         error = getnameinfo(sap, salen, buf, (socklen_t)buflen,
77                                                 NULL, 0, NI_NUMERICHOST);
78         if (error != 0) {
79                 xlog(D_GENERAL, "%s: getnameinfo(3): %s",
80                                 __func__, gai_strerror(error));
81                 return false;
82         }
83         return true;
84 }
85 #else   /* !HAVE_GETNAMEINFO */
86 _Bool
87 statd_present_address(const struct sockaddr *sap, char *buf, const size_t buflen)
88 {
89         const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
90
91         if (sin->sin_family != AF_INET) {
92                 xlog(D_GENERAL, "%s: unsupported address family", __func__);
93                 return false;
94         }
95
96         /* ensure '\0' termination */
97         memset(buf, 0, buflen);
98
99         if (inet_ntop(AF_INET, (char *)&sin->sin_addr,
100                                         buf, (socklen_t)buflen) == NULL) {
101                 xlog(D_GENERAL, "%s: inet_ntop(3): %m", __func__);
102                 return false;
103         }
104         return true;
105 }
106 #endif  /* !HAVE_GETNAMEINFO */
107
108 /*
109  * Look up the hostname; report exceptional errors.  Caller must
110  * call freeaddrinfo(3) if a valid addrinfo is returned.
111  */
112 __attribute_malloc__
113 static struct addrinfo *
114 get_addrinfo(const char *hostname, const struct addrinfo *hint)
115 {
116         struct addrinfo *ai = NULL;
117         int error;
118
119         error = getaddrinfo(hostname, NULL, hint, &ai);
120         switch (error) {
121         case 0:
122                 return ai;
123         case EAI_NONAME:
124                 break;
125         default:
126                 xlog(D_GENERAL, "%s: failed to resolve host %s: %s",
127                                 __func__, hostname, gai_strerror(error));
128         }
129
130         return NULL;
131 }
132
133 #ifdef HAVE_GETNAMEINFO
134 static _Bool
135 get_nameinfo(const struct sockaddr *sap, const socklen_t salen,
136                 /*@out@*/ char *buf, const socklen_t buflen)
137 {
138         int error;
139
140         error = getnameinfo(sap, salen, buf, buflen, NULL, 0, NI_NAMEREQD);
141         if (error != 0) {
142                 xlog(D_GENERAL, "%s: failed to resolve address: %s",
143                                 __func__, gai_strerror(error));
144                 return false;
145         }
146
147         return true;
148 }
149 #else   /* !HAVE_GETNAMEINFO */
150 static _Bool
151 get_nameinfo(const struct sockaddr *sap,
152                 __attribute__ ((unused)) const socklen_t salen,
153                 /*@out@*/ char *buf, socklen_t buflen)
154 {
155         struct sockaddr_in *sin = (struct sockaddr_in *)(char *)sap;
156         struct hostent *hp;
157
158         if (sin->sin_family != AF_INET) {
159                 xlog(D_GENERAL, "%s: unknown address family: %d",
160                                 sin->sin_family);
161                 return false;
162         }
163
164         hp = gethostbyaddr((const char *)&(sin->sin_addr.s_addr),
165                                 sizeof(struct in_addr), AF_INET);
166         if (hp == NULL) {
167                 xlog(D_GENERAL, "%s: failed to resolve address: %m", __func__);
168                 return false;
169         }
170
171         strncpy(buf, hp->h_name, (size_t)buflen);
172         return true;
173 }
174 #endif  /* !HAVE_GETNAMEINFO */
175
176 /**
177  * statd_canonical_name - choose file name for monitor record files
178  * @hostname: C string containing hostname or presentation address
179  *
180  * Returns a '\0'-terminated ASCII string containing a fully qualified
181  * canonical hostname, or NULL if @hostname does not have a reverse
182  * mapping.  Caller must free the result with free(3).
183  *
184  * Incoming hostnames are looked up to determine the canonical hostname,
185  * and incoming presentation addresses are converted to canonical
186  * hostnames.
187  *
188  * We won't monitor peers that don't have a reverse map.  The canonical
189  * name gives us a key for our monitor list.
190  */
191 __attribute_malloc__
192 char *
193 statd_canonical_name(const char *hostname)
194 {
195         struct addrinfo hint = {
196 #ifdef IPV6_SUPPORTED
197                 .ai_family      = AF_UNSPEC,
198 #else   /* !IPV6_SUPPORTED */
199                 .ai_family      = AF_INET,
200 #endif  /* !IPV6_SUPPORTED */
201                 .ai_flags       = AI_NUMERICHOST,
202                 .ai_protocol    = (int)IPPROTO_UDP,
203         };
204         char buf[NI_MAXHOST];
205         struct addrinfo *ai;
206
207         ai = get_addrinfo(hostname, &hint);
208         if (ai != NULL) {
209                 /* @hostname was a presentation address */
210                 _Bool result;
211                 result = get_nameinfo(ai->ai_addr, ai->ai_addrlen,
212                                         buf, (socklen_t)sizeof(buf));
213                 freeaddrinfo(ai);
214                 if (!result)
215                         /* OK to use presentation address,
216                          * if no reverse map exists */
217                         return strdup(hostname);
218                 return strdup(buf);
219         }
220
221         /* @hostname was a hostname */
222         hint.ai_flags = AI_CANONNAME;
223         ai = get_addrinfo(hostname, &hint);
224         if (ai == NULL)
225                 return NULL;
226         strcpy(buf, ai->ai_canonname);
227         freeaddrinfo(ai);
228
229         return strdup(buf);
230 }
231
232 /**
233  * statd_matchhostname - check if two hostnames are equivalent
234  * @hostname1: C string containing hostname
235  * @hostname2: C string containing hostname
236  *
237  * Returns true if the hostnames are the same, the hostnames resolve
238  * to the same canonical name, or the hostnames resolve to at least
239  * one address that is the same.  False is returned if the hostnames
240  * do not match in any of these ways, if either hostname contains
241  * wildcard characters, if either hostname is a netgroup name, or
242  * if an error occurs.
243  */
244 _Bool
245 statd_matchhostname(const char *hostname1, const char *hostname2)
246 {
247         struct addrinfo *ai1, *ai2, *results1 = NULL, *results2 = NULL;
248         struct addrinfo hint = {
249                 .ai_family      = AF_UNSPEC,
250                 .ai_flags       = AI_CANONNAME,
251                 .ai_protocol    = (int)IPPROTO_UDP,
252         };
253         _Bool result = false;
254
255         if (strcasecmp(hostname1, hostname2) == 0) {
256                 result = true;
257                 goto out;
258         }
259
260         results1 = get_addrinfo(hostname1, &hint);
261         if (results1 == NULL)
262                 goto out;
263         results2 = get_addrinfo(hostname2, &hint);
264         if (results2 == NULL)
265                 goto out;
266
267         if (strcasecmp(results1->ai_canonname, results2->ai_canonname) == 0) {
268                 result = true;
269                 goto out;
270         }
271
272         for (ai1 = results1; ai1 != NULL; ai1 = ai1->ai_next)
273                 for (ai2 = results2; ai2 != NULL; ai2 = ai2->ai_next)
274                         if (nfs_compare_sockaddr(ai1->ai_addr, ai2->ai_addr)) {
275                                 result = true;
276                                 break;
277                         }
278
279 out:
280         freeaddrinfo(results2);
281         freeaddrinfo(results1);
282
283         xlog(D_CALL, "%s: hostnames %s", __func__,
284                         (result ? "matched" : "did not match"));
285         return result;
286 }