linux/net/sunrpc/addr.c
<<
>>
Prefs
   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 = kmemdup_nul(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