Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / net / sunrpc / addr.c
1 /*
2  * Copyright 2009, Oracle.  All rights reserved.
3  *
4  * Convert socket addresses to presentation addresses and universal
5  * addresses, and vice versa.
6  *
7  * Universal addresses are introduced by RFC 1833 and further refined by
8  * recent RFCs describing NFSv4.  The universal address format is part
9  * of the external (network) interface provided by rpcbind version 3
10  * and 4, and by NFSv4.  Such an address is a string containing a
11  * presentation format IP address followed by a port number in
12  * "hibyte.lobyte" format.
13  *
14  * IPv6 addresses can also include a scope ID, typically denoted by
15  * a '%' followed by a device name or a non-negative integer.  Refer to
16  * RFC 4291, Section 2.2 for details on IPv6 presentation formats.
17  */
18
19 #include <net/ipv6.h>
20 #include <linux/sunrpc/clnt.h>
21
22 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
23
24 static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap,
25                                   char *buf, const int buflen)
26 {
27         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
28         const struct in6_addr *addr = &sin6->sin6_addr;
29
30         /*
31          * RFC 4291, Section 2.2.2
32          *
33          * Shorthanded ANY address
34          */
35         if (ipv6_addr_any(addr))
36                 return snprintf(buf, buflen, "::");
37
38         /*
39          * RFC 4291, Section 2.2.2
40          *
41          * Shorthanded loopback address
42          */
43         if (ipv6_addr_loopback(addr))
44                 return snprintf(buf, buflen, "::1");
45
46         /*
47          * RFC 4291, Section 2.2.3
48          *
49          * Special presentation address format for mapped v4
50          * addresses.
51          */
52         if (ipv6_addr_v4mapped(addr))
53                 return snprintf(buf, buflen, "::ffff:%pI4",
54                                         &addr->s6_addr32[3]);
55
56         /*
57          * RFC 4291, Section 2.2.1
58          */
59         return snprintf(buf, buflen, "%pI6c", addr);
60 }
61
62 static size_t rpc_ntop6(const struct sockaddr *sap,
63                         char *buf, const size_t buflen)
64 {
65         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
66         char scopebuf[IPV6_SCOPE_ID_LEN];
67         size_t len;
68         int rc;
69
70         len = rpc_ntop6_noscopeid(sap, buf, buflen);
71         if (unlikely(len == 0))
72                 return len;
73
74         if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
75                 return len;
76         if (sin6->sin6_scope_id == 0)
77                 return len;
78
79         rc = snprintf(scopebuf, sizeof(scopebuf), "%c%u",
80                         IPV6_SCOPE_DELIMITER, sin6->sin6_scope_id);
81         if (unlikely((size_t)rc > sizeof(scopebuf)))
82                 return 0;
83
84         len += rc;
85         if (unlikely(len > buflen))
86                 return 0;
87
88         strcat(buf, scopebuf);
89         return len;
90 }
91
92 #else   /* !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) */
93
94 static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap,
95                                   char *buf, const int buflen)
96 {
97         return 0;
98 }
99
100 static size_t rpc_ntop6(const struct sockaddr *sap,
101                         char *buf, const size_t buflen)
102 {
103         return 0;
104 }
105
106 #endif  /* !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) */
107
108 static int rpc_ntop4(const struct sockaddr *sap,
109                      char *buf, const size_t buflen)
110 {
111         const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
112
113         return snprintf(buf, buflen, "%pI4", &sin->sin_addr);
114 }
115
116 /**
117  * rpc_ntop - construct a presentation address in @buf
118  * @sap: socket address
119  * @buf: construction area
120  * @buflen: size of @buf, in bytes
121  *
122  * Plants a %NUL-terminated string in @buf and returns the length
123  * of the string, excluding the %NUL.  Otherwise zero is returned.
124  */
125 size_t rpc_ntop(const struct sockaddr *sap, char *buf, const size_t buflen)
126 {
127         switch (sap->sa_family) {
128         case AF_INET:
129                 return rpc_ntop4(sap, buf, buflen);
130         case AF_INET6:
131                 return rpc_ntop6(sap, buf, buflen);
132         }
133
134         return 0;
135 }
136 EXPORT_SYMBOL_GPL(rpc_ntop);
137
138 static size_t rpc_pton4(const char *buf, const size_t buflen,
139                         struct sockaddr *sap, const size_t salen)
140 {
141         struct sockaddr_in *sin = (struct sockaddr_in *)sap;
142         u8 *addr = (u8 *)&sin->sin_addr.s_addr;
143
144         if (buflen > INET_ADDRSTRLEN || salen < sizeof(struct sockaddr_in))
145                 return 0;
146
147         memset(sap, 0, sizeof(struct sockaddr_in));
148
149         if (in4_pton(buf, buflen, addr, '\0', NULL) == 0)
150                 return 0;
151
152         sin->sin_family = AF_INET;
153         return sizeof(struct sockaddr_in);;
154 }
155
156 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
157 static int rpc_parse_scope_id(const char *buf, const size_t buflen,
158                               const char *delim, struct sockaddr_in6 *sin6)
159 {
160         char *p;
161         size_t len;
162
163         if ((buf + buflen) == delim)
164                 return 1;
165
166         if (*delim != IPV6_SCOPE_DELIMITER)
167                 return 0;
168
169         if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
170                 return 0;
171
172         len = (buf + buflen) - delim - 1;
173         p = kstrndup(delim + 1, len, GFP_KERNEL);
174         if (p) {
175                 unsigned long scope_id = 0;
176                 struct net_device *dev;
177
178                 dev = dev_get_by_name(&init_net, p);
179                 if (dev != NULL) {
180                         scope_id = dev->ifindex;
181                         dev_put(dev);
182                 } else {
183                         if (strict_strtoul(p, 10, &scope_id) == 0) {
184                                 kfree(p);
185                                 return 0;
186                         }
187                 }
188
189                 kfree(p);
190
191                 sin6->sin6_scope_id = scope_id;
192                 return 1;
193         }
194
195         return 0;
196 }
197
198 static size_t rpc_pton6(const char *buf, const size_t buflen,
199                         struct sockaddr *sap, const size_t salen)
200 {
201         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
202         u8 *addr = (u8 *)&sin6->sin6_addr.in6_u;
203         const char *delim;
204
205         if (buflen > (INET6_ADDRSTRLEN + IPV6_SCOPE_ID_LEN) ||
206             salen < sizeof(struct sockaddr_in6))
207                 return 0;
208
209         memset(sap, 0, sizeof(struct sockaddr_in6));
210
211         if (in6_pton(buf, buflen, addr, IPV6_SCOPE_DELIMITER, &delim) == 0)
212                 return 0;
213
214         if (!rpc_parse_scope_id(buf, buflen, delim, sin6))
215                 return 0;
216
217         sin6->sin6_family = AF_INET6;
218         return sizeof(struct sockaddr_in6);
219 }
220 #else
221 static size_t rpc_pton6(const char *buf, const size_t buflen,
222                         struct sockaddr *sap, const size_t salen)
223 {
224         return 0;
225 }
226 #endif
227
228 /**
229  * rpc_pton - Construct a sockaddr in @sap
230  * @buf: C string containing presentation format IP address
231  * @buflen: length of presentation address in bytes
232  * @sap: buffer into which to plant socket address
233  * @salen: size of buffer in bytes
234  *
235  * Returns the size of the socket address if successful; otherwise
236  * zero is returned.
237  *
238  * Plants a socket address in @sap and returns the size of the
239  * socket address, if successful.  Returns zero if an error
240  * occurred.
241  */
242 size_t rpc_pton(const char *buf, const size_t buflen,
243                 struct sockaddr *sap, const size_t salen)
244 {
245         unsigned int i;
246
247         for (i = 0; i < buflen; i++)
248                 if (buf[i] == ':')
249                         return rpc_pton6(buf, buflen, sap, salen);
250         return rpc_pton4(buf, buflen, sap, salen);
251 }
252 EXPORT_SYMBOL_GPL(rpc_pton);
253
254 /**
255  * rpc_sockaddr2uaddr - Construct a universal address string from @sap.
256  * @sap: socket address
257  *
258  * Returns a %NUL-terminated string in dynamically allocated memory;
259  * otherwise NULL is returned if an error occurred.  Caller must
260  * free the returned string.
261  */
262 char *rpc_sockaddr2uaddr(const struct sockaddr *sap)
263 {
264         char portbuf[RPCBIND_MAXUADDRPLEN];
265         char addrbuf[RPCBIND_MAXUADDRLEN];
266         unsigned short port;
267
268         switch (sap->sa_family) {
269         case AF_INET:
270                 if (rpc_ntop4(sap, addrbuf, sizeof(addrbuf)) == 0)
271                         return NULL;
272                 port = ntohs(((struct sockaddr_in *)sap)->sin_port);
273                 break;
274         case AF_INET6:
275                 if (rpc_ntop6_noscopeid(sap, addrbuf, sizeof(addrbuf)) == 0)
276                         return NULL;
277                 port = ntohs(((struct sockaddr_in6 *)sap)->sin6_port);
278                 break;
279         default:
280                 return NULL;
281         }
282
283         if (snprintf(portbuf, sizeof(portbuf),
284                      ".%u.%u", port >> 8, port & 0xff) > (int)sizeof(portbuf))
285                 return NULL;
286
287         if (strlcat(addrbuf, portbuf, sizeof(addrbuf)) > sizeof(addrbuf))
288                 return NULL;
289
290         return kstrdup(addrbuf, GFP_KERNEL);
291 }
292 EXPORT_SYMBOL_GPL(rpc_sockaddr2uaddr);
293
294 /**
295  * rpc_uaddr2sockaddr - convert a universal address to a socket address.
296  * @uaddr: C string containing universal address to convert
297  * @uaddr_len: length of universal address string
298  * @sap: buffer into which to plant socket address
299  * @salen: size of buffer
300  *
301  * @uaddr does not have to be '\0'-terminated, but strict_strtoul() and
302  * rpc_pton() require proper string termination to be successful.
303  *
304  * Returns the size of the socket address if successful; otherwise
305  * zero is returned.
306  */
307 size_t rpc_uaddr2sockaddr(const char *uaddr, const size_t uaddr_len,
308                           struct sockaddr *sap, const size_t salen)
309 {
310         char *c, buf[RPCBIND_MAXUADDRLEN + sizeof('\0')];
311         unsigned long portlo, porthi;
312         unsigned short port;
313
314         if (uaddr_len > RPCBIND_MAXUADDRLEN)
315                 return 0;
316
317         memcpy(buf, uaddr, uaddr_len);
318
319         buf[uaddr_len] = '\0';
320         c = strrchr(buf, '.');
321         if (unlikely(c == NULL))
322                 return 0;
323         if (unlikely(strict_strtoul(c + 1, 10, &portlo) != 0))
324                 return 0;
325         if (unlikely(portlo > 255))
326                 return 0;
327
328         *c = '\0';
329         c = strrchr(buf, '.');
330         if (unlikely(c == NULL))
331                 return 0;
332         if (unlikely(strict_strtoul(c + 1, 10, &porthi) != 0))
333                 return 0;
334         if (unlikely(porthi > 255))
335                 return 0;
336
337         port = (unsigned short)((porthi << 8) | portlo);
338
339         *c = '\0';
340         if (rpc_pton(buf, strlen(buf), sap, salen) == 0)
341                 return 0;
342
343         switch (sap->sa_family) {
344         case AF_INET:
345                 ((struct sockaddr_in *)sap)->sin_port = htons(port);
346                 return sizeof(struct sockaddr_in);
347         case AF_INET6:
348                 ((struct sockaddr_in6 *)sap)->sin6_port = htons(port);
349                 return sizeof(struct sockaddr_in6);
350         }
351
352         return 0;
353 }
354 EXPORT_SYMBOL_GPL(rpc_uaddr2sockaddr);