SUNRPC: Provide functions for managing universal addresses
authorChuck Lever <chuck.lever@oracle.com>
Sun, 9 Aug 2009 19:09:34 +0000 (15:09 -0400)
committerTrond Myklebust <Trond.Myklebust@netapp.com>
Sun, 9 Aug 2009 19:09:34 +0000 (15:09 -0400)
Introduce a set of functions in the kernel's RPC implementation for
converting between a socket address and either a standard
presentation address string or an RPC universal address.

The universal address functions will be used to encode and decode
RPCB_FOO and NFSv4 SETCLIENTID arguments.  The other functions are
part of a previous promise to deliver shared functions that can be
used by upper-layer protocols to display and manipulate IP
addresses.

The kernel's current address printf formatters were designed
specifically for kernel to user-space APIs that require a particular
string format for socket addresses, thus are somewhat limited for the
purposes of sunrpc.ko.  The formatter for IPv6 addresses, %pI6, does
not support short-handing or scope IDs.  Also, these printf formatters
are unique per address family, so a separate formatter string is
required for printing AF_INET and AF_INET6 addresses.

Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
fs/nfs/internal.h
include/linux/sunrpc/clnt.h
net/sunrpc/Makefile
net/sunrpc/addr.c [new file with mode: 0644]

index 8d2b71d57d2964b9d45c08a09ebac41212966bc0..ff68397f9b1963da23d9ff6c27dcdcd54ad18de8 100644 (file)
@@ -370,8 +370,6 @@ unsigned int nfs_page_array_len(unsigned int base, size_t len)
                PAGE_SIZE - 1) >> PAGE_SHIFT;
 }
 
-#define IPV6_SCOPE_DELIMITER   '%'
-
 /*
  * Set the port number in an address.  Be agnostic about the address
  * family.
index 37881f1a0bd70af99e72302f408adfaf7b4cb30d..2636e8ad551c3a0b544f3cbc391e212ac9fe5301 100644 (file)
@@ -9,6 +9,10 @@
 #ifndef _LINUX_SUNRPC_CLNT_H
 #define _LINUX_SUNRPC_CLNT_H
 
+#include <linux/socket.h>
+#include <linux/in.h>
+#include <linux/in6.h>
+
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/xprt.h>
@@ -151,5 +155,39 @@ void               rpc_force_rebind(struct rpc_clnt *);
 size_t         rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t);
 const char     *rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
 
+size_t         rpc_ntop(const struct sockaddr *, char *, const size_t);
+size_t         rpc_pton(const char *, const size_t,
+                        struct sockaddr *, const size_t);
+char *         rpc_sockaddr2uaddr(const struct sockaddr *);
+size_t         rpc_uaddr2sockaddr(const char *, const size_t,
+                                  struct sockaddr *, const size_t);
+
+static inline unsigned short rpc_get_port(const struct sockaddr *sap)
+{
+       switch (sap->sa_family) {
+       case AF_INET:
+               return ntohs(((struct sockaddr_in *)sap)->sin_port);
+       case AF_INET6:
+               return ntohs(((struct sockaddr_in6 *)sap)->sin6_port);
+       }
+       return 0;
+}
+
+static inline void rpc_set_port(struct sockaddr *sap,
+                               const unsigned short port)
+{
+       switch (sap->sa_family) {
+       case AF_INET:
+               ((struct sockaddr_in *)sap)->sin_port = htons(port);
+               break;
+       case AF_INET6:
+               ((struct sockaddr_in6 *)sap)->sin6_port = htons(port);
+               break;
+       }
+}
+
+#define IPV6_SCOPE_DELIMITER           '%'
+#define IPV6_SCOPE_ID_LEN              sizeof("%nnnnnnnnnn")
+
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_CLNT_H */
index db73fd2a3f0e4110dff6dd9f879ef6060efc7a4c..9d2fca5ad14a889c36cc5e782c10bcd64d959e97 100644 (file)
@@ -10,7 +10,7 @@ obj-$(CONFIG_SUNRPC_XPRT_RDMA) += xprtrdma/
 sunrpc-y := clnt.o xprt.o socklib.o xprtsock.o sched.o \
            auth.o auth_null.o auth_unix.o auth_generic.o \
            svc.o svcsock.o svcauth.o svcauth_unix.o \
-           rpcb_clnt.o timer.o xdr.o \
+           addr.o rpcb_clnt.o timer.o xdr.o \
            sunrpc_syms.o cache.o rpc_pipe.o \
            svc_xprt.o
 sunrpc-$(CONFIG_NFS_V4_1) += backchannel_rqst.o bc_svc.o
diff --git a/net/sunrpc/addr.c b/net/sunrpc/addr.c
new file mode 100644 (file)
index 0000000..22e8fd8
--- /dev/null
@@ -0,0 +1,364 @@
+/*
+ * 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/clnt.h>
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+
+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
+        *
+        * To keep the result as short as possible, especially
+        * since we don't shorthand, we don't want leading zeros
+        * in each halfword, so avoid %pI6.
+        */
+       return snprintf(buf, buflen, "%x:%x:%x:%x:%x:%x:%x:%x",
+               ntohs(addr->s6_addr16[0]), ntohs(addr->s6_addr16[1]),
+               ntohs(addr->s6_addr16[2]), ntohs(addr->s6_addr16[3]),
+               ntohs(addr->s6_addr16[4]), ntohs(addr->s6_addr16[5]),
+               ntohs(addr->s6_addr16[6]), ntohs(addr->s6_addr16[7]));
+}
+
+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) &&
+           !(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_SITELOCAL))
+               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  /* !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) */
+
+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 /* !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) */
+
+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 defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static int rpc_parse_scope_id(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) &&
+           !(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_SITELOCAL))
+               return 0;
+
+       len = (buf + buflen) - delim - 1;
+       p = kstrndup(delim + 1, len, GFP_KERNEL);
+       if (p) {
+               unsigned long scope_id = 0;
+               struct net_device *dev;
+
+               dev = dev_get_by_name(&init_net, p);
+               if (dev != NULL) {
+                       scope_id = dev->ifindex;
+                       dev_put(dev);
+               } else {
+                       if (strict_strtoul(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(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(buf, buflen, delim, sin6))
+               return 0;
+
+       sin6->sin6_family = AF_INET6;
+       return sizeof(struct sockaddr_in6);
+}
+#else
+static size_t rpc_pton6(const char *buf, const size_t buflen,
+                       struct sockaddr *sap, const size_t salen)
+{
+       return 0;
+}
+#endif
+
+/**
+ * rpc_pton - Construct a sockaddr in @sap
+ * @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(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(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
+ *
+ * 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)
+{
+       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_KERNEL);
+}
+EXPORT_SYMBOL_GPL(rpc_sockaddr2uaddr);
+
+/**
+ * rpc_uaddr2sockaddr - convert a universal address to a socket address.
+ * @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
+ *
+ * Returns the size of the socket address if successful; otherwise
+ * zero is returned.
+ */
+size_t rpc_uaddr2sockaddr(const char *uaddr, const size_t uaddr_len,
+                         struct sockaddr *sap, const size_t salen)
+{
+       char *c, buf[RPCBIND_MAXUADDRLEN];
+       unsigned long portlo, porthi;
+       unsigned short port;
+
+       if (uaddr_len > sizeof(buf))
+               return 0;
+
+       memcpy(buf, uaddr, uaddr_len);
+
+       buf[uaddr_len] = '\n';
+       buf[uaddr_len + 1] = '\0';
+
+       c = strrchr(buf, '.');
+       if (unlikely(c == NULL))
+               return 0;
+       if (unlikely(strict_strtoul(c + 1, 10, &portlo) != 0))
+               return 0;
+       if (unlikely(portlo > 255))
+               return 0;
+
+       c[0] = '\n';
+       c[1] = '\0';
+
+       c = strrchr(buf, '.');
+       if (unlikely(c == NULL))
+               return 0;
+       if (unlikely(strict_strtoul(c + 1, 10, &porthi) != 0))
+               return 0;
+       if (unlikely(porthi > 255))
+               return 0;
+
+       port = (unsigned short)((porthi << 8) | portlo);
+
+       c[0] = '\0';
+
+       if (rpc_pton(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);