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