| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * Copyright 2009, Oracle. All rights reserved. |
| * |
| * Convert socket addresses to presentation addresses and universal |
| * addresses, and vice versa. |
| * |
| * Universal addresses are introduced by RFC 1833 and further refined by |
| * recent RFCs describing NFSv4. The universal address format is part |
| * of the external (network) interface provided by rpcbind version 3 |
| * and 4, and by NFSv4. Such an address is a string containing a |
| * presentation format IP address followed by a port number in |
| * "hibyte.lobyte" format. |
| * |
| * IPv6 addresses can also include a scope ID, typically denoted by |
| * a '%' followed by a device name or a non-negative integer. Refer to |
| * RFC 4291, Section 2.2 for details on IPv6 presentation formats. |
| */ |
| |
| #include <net/ipv6.h> |
| #include <linux/sunrpc/addr.h> |
| #include <linux/sunrpc/msg_prot.h> |
| #include <linux/slab.h> |
| #include <linux/export.h> |
| |
| #if IS_ENABLED(CONFIG_IPV6) |
| |
| static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap, |
| char *buf, const int buflen) |
| { |
| const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; |
| const struct in6_addr *addr = &sin6->sin6_addr; |
| |
| /* |
| * RFC 4291, Section 2.2.2 |
| * |
| * Shorthanded ANY address |
| */ |
| if (ipv6_addr_any(addr)) |
| return snprintf(buf, buflen, "::"); |
| |
| /* |
| * RFC 4291, Section 2.2.2 |
| * |
| * Shorthanded loopback address |
| */ |
| if (ipv6_addr_loopback(addr)) |
| return snprintf(buf, buflen, "::1"); |
| |
| /* |
| * RFC 4291, Section 2.2.3 |
| * |
| * Special presentation address format for mapped v4 |
| * addresses. |
| */ |
| if (ipv6_addr_v4mapped(addr)) |
| return snprintf(buf, buflen, "::ffff:%pI4", |
| &addr->s6_addr32[3]); |
| |
| /* |
| * RFC 4291, Section 2.2.1 |
| */ |
| return snprintf(buf, buflen, "%pI6c", addr); |
| } |
| |
| static size_t rpc_ntop6(const struct sockaddr *sap, |
| char *buf, const size_t buflen) |
| { |
| const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; |
| char scopebuf[IPV6_SCOPE_ID_LEN]; |
| size_t len; |
| int rc; |
| |
| len = rpc_ntop6_noscopeid(sap, buf, buflen); |
| if (unlikely(len == 0)) |
| return len; |
| |
| if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)) |
| return len; |
| if (sin6->sin6_scope_id == 0) |
| return len; |
| |
| rc = snprintf(scopebuf, sizeof(scopebuf), "%c%u", |
| IPV6_SCOPE_DELIMITER, sin6->sin6_scope_id); |
| if (unlikely((size_t)rc > sizeof(scopebuf))) |
| return 0; |
| |
| len += rc; |
| if (unlikely(len > buflen)) |
| return 0; |
| |
| strcat(buf, scopebuf); |
| return len; |
| } |
| |
| #else /* !IS_ENABLED(CONFIG_IPV6) */ |
| |
| static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap, |
| char *buf, const int buflen) |
| { |
| return 0; |
| } |
| |
| static size_t rpc_ntop6(const struct sockaddr *sap, |
| char *buf, const size_t buflen) |
| { |
| return 0; |
| } |
| |
| #endif /* !IS_ENABLED(CONFIG_IPV6) */ |
| |
| static int rpc_ntop4(const struct sockaddr *sap, |
| char *buf, const size_t buflen) |
| { |
| const struct sockaddr_in *sin = (struct sockaddr_in *)sap; |
| |
| return snprintf(buf, buflen, "%pI4", &sin->sin_addr); |
| } |
| |
| /** |
| * rpc_ntop - construct a presentation address in @buf |
| * @sap: socket address |
| * @buf: construction area |
| * @buflen: size of @buf, in bytes |
| * |
| * Plants a %NUL-terminated string in @buf and returns the length |
| * of the string, excluding the %NUL. Otherwise zero is returned. |
| */ |
| size_t rpc_ntop(const struct sockaddr *sap, char *buf, const size_t buflen) |
| { |
| switch (sap->sa_family) { |
| case AF_INET: |
| return rpc_ntop4(sap, buf, buflen); |
| case AF_INET6: |
| return rpc_ntop6(sap, buf, buflen); |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(rpc_ntop); |
| |
| static size_t rpc_pton4(const char *buf, const size_t buflen, |
| struct sockaddr *sap, const size_t salen) |
| { |
| struct sockaddr_in *sin = (struct sockaddr_in *)sap; |
| u8 *addr = (u8 *)&sin->sin_addr.s_addr; |
| |
| if (buflen > INET_ADDRSTRLEN || salen < sizeof(struct sockaddr_in)) |
| return 0; |
| |
| memset(sap, 0, sizeof(struct sockaddr_in)); |
| |
| if (in4_pton(buf, buflen, addr, '\0', NULL) == 0) |
| return 0; |
| |
| sin->sin_family = AF_INET; |
| return sizeof(struct sockaddr_in); |
| } |
| |
| #if IS_ENABLED(CONFIG_IPV6) |
| static int rpc_parse_scope_id(struct net *net, const char *buf, |
| const size_t buflen, const char *delim, |
| struct sockaddr_in6 *sin6) |
| { |
| char *p; |
| size_t len; |
| |
| if ((buf + buflen) == delim) |
| return 1; |
| |
| if (*delim != IPV6_SCOPE_DELIMITER) |
| return 0; |
| |
| if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)) |
| return 0; |
| |
| len = (buf + buflen) - delim - 1; |
| p = kmemdup_nul(delim + 1, len, GFP_KERNEL); |
| if (p) { |
| u32 scope_id = 0; |
| struct net_device *dev; |
| |
| dev = dev_get_by_name(net, p); |
| if (dev != NULL) { |
| scope_id = dev->ifindex; |
| dev_put(dev); |
| } else { |
| if (kstrtou32(p, 10, &scope_id) == 0) { |
| kfree(p); |
| return 0; |
| } |
| } |
| |
| kfree(p); |
| |
| sin6->sin6_scope_id = scope_id; |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| static size_t rpc_pton6(struct net *net, const char *buf, const size_t buflen, |
| struct sockaddr *sap, const size_t salen) |
| { |
| struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; |
| u8 *addr = (u8 *)&sin6->sin6_addr.in6_u; |
| const char *delim; |
| |
| if (buflen > (INET6_ADDRSTRLEN + IPV6_SCOPE_ID_LEN) || |
| salen < sizeof(struct sockaddr_in6)) |
| return 0; |
| |
| memset(sap, 0, sizeof(struct sockaddr_in6)); |
| |
| if (in6_pton(buf, buflen, addr, IPV6_SCOPE_DELIMITER, &delim) == 0) |
| return 0; |
| |
| if (!rpc_parse_scope_id(net, buf, buflen, delim, sin6)) |
| return 0; |
| |
| sin6->sin6_family = AF_INET6; |
| return sizeof(struct sockaddr_in6); |
| } |
| #else |
| static size_t rpc_pton6(struct net *net, const char *buf, const size_t buflen, |
| struct sockaddr *sap, const size_t salen) |
| { |
| return 0; |
| } |
| #endif |
| |
| /** |
| * rpc_pton - Construct a sockaddr in @sap |
| * @net: applicable network namespace |
| * @buf: C string containing presentation format IP address |
| * @buflen: length of presentation address in bytes |
| * @sap: buffer into which to plant socket address |
| * @salen: size of buffer in bytes |
| * |
| * Returns the size of the socket address if successful; otherwise |
| * zero is returned. |
| * |
| * Plants a socket address in @sap and returns the size of the |
| * socket address, if successful. Returns zero if an error |
| * occurred. |
| */ |
| size_t rpc_pton(struct net *net, const char *buf, const size_t buflen, |
| struct sockaddr *sap, const size_t salen) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < buflen; i++) |
| if (buf[i] == ':') |
| return rpc_pton6(net, buf, buflen, sap, salen); |
| return rpc_pton4(buf, buflen, sap, salen); |
| } |
| EXPORT_SYMBOL_GPL(rpc_pton); |
| |
| /** |
| * rpc_sockaddr2uaddr - Construct a universal address string from @sap. |
| * @sap: socket address |
| * @gfp_flags: allocation mode |
| * |
| * Returns a %NUL-terminated string in dynamically allocated memory; |
| * otherwise NULL is returned if an error occurred. Caller must |
| * free the returned string. |
| */ |
| char *rpc_sockaddr2uaddr(const struct sockaddr *sap, gfp_t gfp_flags) |
| { |
| char portbuf[RPCBIND_MAXUADDRPLEN]; |
| char addrbuf[RPCBIND_MAXUADDRLEN]; |
| unsigned short port; |
| |
| switch (sap->sa_family) { |
| case AF_INET: |
| if (rpc_ntop4(sap, addrbuf, sizeof(addrbuf)) == 0) |
| return NULL; |
| port = ntohs(((struct sockaddr_in *)sap)->sin_port); |
| break; |
| case AF_INET6: |
| if (rpc_ntop6_noscopeid(sap, addrbuf, sizeof(addrbuf)) == 0) |
| return NULL; |
| port = ntohs(((struct sockaddr_in6 *)sap)->sin6_port); |
| break; |
| default: |
| return NULL; |
| } |
| |
| if (snprintf(portbuf, sizeof(portbuf), |
| ".%u.%u", port >> 8, port & 0xff) > (int)sizeof(portbuf)) |
| return NULL; |
| |
| if (strlcat(addrbuf, portbuf, sizeof(addrbuf)) > sizeof(addrbuf)) |
| return NULL; |
| |
| return kstrdup(addrbuf, gfp_flags); |
| } |
| |
| /** |
| * rpc_uaddr2sockaddr - convert a universal address to a socket address. |
| * @net: applicable network namespace |
| * @uaddr: C string containing universal address to convert |
| * @uaddr_len: length of universal address string |
| * @sap: buffer into which to plant socket address |
| * @salen: size of buffer |
| * |
| * @uaddr does not have to be '\0'-terminated, but kstrtou8() and |
| * rpc_pton() require proper string termination to be successful. |
| * |
| * Returns the size of the socket address if successful; otherwise |
| * zero is returned. |
| */ |
| size_t rpc_uaddr2sockaddr(struct net *net, const char *uaddr, |
| const size_t uaddr_len, struct sockaddr *sap, |
| const size_t salen) |
| { |
| char *c, buf[RPCBIND_MAXUADDRLEN + sizeof('\0')]; |
| u8 portlo, porthi; |
| unsigned short port; |
| |
| if (uaddr_len > RPCBIND_MAXUADDRLEN) |
| return 0; |
| |
| memcpy(buf, uaddr, uaddr_len); |
| |
| buf[uaddr_len] = '\0'; |
| c = strrchr(buf, '.'); |
| if (unlikely(c == NULL)) |
| return 0; |
| if (unlikely(kstrtou8(c + 1, 10, &portlo) != 0)) |
| return 0; |
| |
| *c = '\0'; |
| c = strrchr(buf, '.'); |
| if (unlikely(c == NULL)) |
| return 0; |
| if (unlikely(kstrtou8(c + 1, 10, &porthi) != 0)) |
| return 0; |
| |
| port = (unsigned short)((porthi << 8) | portlo); |
| |
| *c = '\0'; |
| if (rpc_pton(net, buf, strlen(buf), sap, salen) == 0) |
| return 0; |
| |
| switch (sap->sa_family) { |
| case AF_INET: |
| ((struct sockaddr_in *)sap)->sin_port = htons(port); |
| return sizeof(struct sockaddr_in); |
| case AF_INET6: |
| ((struct sockaddr_in6 *)sap)->sin6_port = htons(port); |
| return sizeof(struct sockaddr_in6); |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(rpc_uaddr2sockaddr); |