lib/replace/inet_ntop.c

   1 /*
   2  * Copyright (C) 1996-2001  Internet Software Consortium.
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
   9  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
  10  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  11  * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  13  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  14  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  15  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18
  19 #include "replace.h"
  20 #include "system/network.h"
  21
  22 #define NS_INT16SZ       2
  23 #define NS_IN6ADDRSZ    16
  24
  25 /*
  26  * WARNING: Don't even consider trying to compile this on a system where
  27  * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
  28  */
  29
  30 static const char *inet_ntop4(const unsigned char *src, char *dst,
  31                               socklen_t size);
  32
  33 #ifdef AF_INET6
  34 static const char *inet_ntop6(const unsigned char *src, char *dst,
  35                               socklen_t size);
  36 #endif
  37
  38 /* char *
  39  * isc_net_ntop(af, src, dst, size)
  40  *      convert a network format address to presentation format.
  41  * return:
  42  *      pointer to presentation format address (`dst'), or NULL (see errno).
  43  * author:
  44  *      Paul Vixie, 1996.
  45  */
  46 const char *
  47 rep_inet_ntop(int af, const void *src, char *dst, socklen_t size)
  48 {
  49         switch (af) {
  50         case AF_INET:
  51                 return (inet_ntop4(src, dst, size));
  52 #ifdef AF_INET6
  53         case AF_INET6:
  54                 return (inet_ntop6(src, dst, size));
  55 #endif
  56         default:
  57                 errno = EAFNOSUPPORT;
  58                 return (NULL);
  59         }
  60         /* NOTREACHED */
  61 }
  62
  63 /* const char *
  64  * inet_ntop4(src, dst, size)
  65  *      format an IPv4 address
  66  * return:
  67  *      `dst' (as a const)
  68  * author:
  69  *      Paul Vixie, 1996.
  70  */
  71 static const char *
  72 inet_ntop4(const unsigned char *src, char *dst, socklen_t size)
  73 {
  74         char tmp[sizeof("255.255.255.255")];
  75         size_t len;
  76
  77         len = snprintf(tmp,
  78                        sizeof(tmp),
  79                        "%hhu.%hhu.%hhu.%hhu",
  80                        src[0],
  81                        src[1],
  82                        src[2],
  83                        src[3]);
  84         if (len >= size) {
  85                 errno = ENOSPC;
  86                 return (NULL);
  87         }
  88         memcpy(dst, tmp, len + 1);
  89
  90         return (dst);
  91 }
  92
  93 /* const char *
  94  * isc_inet_ntop6(src, dst, size)
  95  *      convert IPv6 binary address into presentation (printable) format
  96  * author:
  97  *      Paul Vixie, 1996.
  98  */
  99 #ifdef AF_INET6
 100 static const char *
 101 inet_ntop6(const unsigned char *src, char *dst, socklen_t size)
 102 {
 103         /*
 104          * Note that int32_t and int16_t need only be "at least" large enough
 105          * to contain a value of the specified size.  On some systems, like
 106          * Crays, there is no such thing as an integer variable with 16 bits.
 107          * Keep this in mind if you think this function should have been coded
 108          * to use pointer overlays.  All the world's not a VAX.
 109          */
 110         char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp;
 111         struct { int base, len; } best, cur;
 112         unsigned int words[NS_IN6ADDRSZ / NS_INT16SZ];
 113         int i, inc;
 114
 115         /*
 116          * Preprocess:
 117          *      Copy the input (bytewise) array into a wordwise array.
 118          *      Find the longest run of 0x00's in src[] for :: shorthanding.
 119          */
 120         memset(words, '\0', sizeof words);
 121         for (i = 0; i < NS_IN6ADDRSZ; i++)
 122                 words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
 123         best.base = -1;
 124         best.len = 0;
 125         cur.base = -1;
 126         cur.len = 0;
 127         for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
 128                 if (words[i] == 0) {
 129                         if (cur.base == -1)
 130                                 cur.base = i, cur.len = 1;
 131                         else
 132                                 cur.len++;
 133                 } else {
 134                         if (cur.base != -1) {
 135                                 if (best.base == -1 || cur.len > best.len)
 136                                         best = cur;
 137                                 cur.base = -1;
 138                         }
 139                 }
 140         }
 141         if (cur.base != -1) {
 142                 if (best.base == -1 || cur.len > best.len)
 143                         best = cur;
 144         }
 145         if (best.base != -1 && best.len < 2)
 146                 best.base = -1;
 147
 148         /*
 149          * Format the result.
 150          */
 151         tp = tmp;
 152         for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
 153                 /* Are we inside the best run of 0x00's? */
 154                 if (best.base != -1 && i >= best.base &&
 155                     i < (best.base + best.len)) {
 156                         if (i == best.base)
 157                                 *tp++ = ':';
 158                         continue;
 159                 }
 160                 /* Are we following an initial run of 0x00s or any real hex? */
 161                 if (i != 0)
 162                         *tp++ = ':';
 163                 /* Is this address an encapsulated IPv4? */
 164                 if (i == 6 && best.base == 0 &&
 165                     (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
 166                         if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp)))
 167                                 return (NULL);
 168                         tp += strlen(tp);
 169                         break;
 170                 }
 171                 inc = snprintf(tp, 5, "%x", words[i]);
 172                 if (inc >= 5) {
 173                         abort();
 174                 }
 175                 tp += inc;
 176         }
 177         /* Was it a trailing run of 0x00's? */
 178         if (best.base != -1 && (best.base + best.len) ==
 179             (NS_IN6ADDRSZ / NS_INT16SZ))
 180                 *tp++ = ':';
 181         *tp++ = '\0';
 182
 183         /*
 184          * Check for overflow, copy, and we're done.
 185          */
 186         if ((size_t)(tp - tmp) > size) {
 187                 errno = ENOSPC;
 188                 return (NULL);
 189         }
 190         memcpy(dst, tmp, tp - tmp);
 191         return (dst);
 192 }
 193 #endif /* AF_INET6 */