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