net/sunrpc/addr.c

   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
  27 static 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
  65 static 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
  97 static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap,
  98                                   char *buf, const int buflen)
  99 {
 100         return 0;
 101 }
 102
 103 static 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
 111 static 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  */
 128 size_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 }
 139 EXPORT_SYMBOL_GPL(rpc_ntop);
 140
 141 static 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)
 160 static 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
 202 static 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
 225 static 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  */
 247 size_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 }
 257 EXPORT_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  */
 268 char *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  */
 313 size_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 }
 357 EXPORT_SYMBOL_GPL(rpc_uaddr2sockaddr);