LCOV - code coverage report
Current view: top level - src/port - inet_net_ntop.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 78 93 83.9 %
Date: 2019-11-13 23:06:49 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
       3             :  * Copyright (c) 1996,1999 by Internet Software Consortium.
       4             :  *
       5             :  * Permission to use, copy, modify, and distribute this software for any
       6             :  * purpose with or without fee is hereby granted, provided that the above
       7             :  * copyright notice and this permission notice appear in all copies.
       8             :  *
       9             :  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
      10             :  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
      11             :  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
      12             :  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
      13             :  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
      14             :  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
      15             :  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      16             :  *
      17             :  *    src/port/inet_net_ntop.c
      18             :  */
      19             : 
      20             : #if defined(LIBC_SCCS) && !defined(lint)
      21             : static const char rcsid[] = "Id: inet_net_ntop.c,v 1.1.2.2 2004/03/09 09:17:27 marka Exp $";
      22             : #endif
      23             : 
      24             : #ifndef FRONTEND
      25             : #include "postgres.h"
      26             : #else
      27             : #include "postgres_fe.h"
      28             : #endif
      29             : 
      30             : #include <sys/socket.h>
      31             : #include <netinet/in.h>
      32             : #include <arpa/inet.h>
      33             : 
      34             : #ifndef FRONTEND
      35             : #include "utils/inet.h"
      36             : #else
      37             : /*
      38             :  * In a frontend build, we can't include inet.h, but we still need to have
      39             :  * sensible definitions of these two constants.  Note that pg_inet_net_ntop()
      40             :  * assumes that PGSQL_AF_INET is equal to AF_INET.
      41             :  */
      42             : #define PGSQL_AF_INET   (AF_INET + 0)
      43             : #define PGSQL_AF_INET6  (AF_INET + 1)
      44             : #endif
      45             : 
      46             : 
      47             : #define NS_IN6ADDRSZ 16
      48             : #define NS_INT16SZ 2
      49             : 
      50             : #ifdef SPRINTF_CHAR
      51             : #define SPRINTF(x) strlen(sprintf/**/x)
      52             : #else
      53             : #define SPRINTF(x) ((size_t)sprintf x)
      54             : #endif
      55             : 
      56             : static char *inet_net_ntop_ipv4(const u_char *src, int bits,
      57             :                                 char *dst, size_t size);
      58             : static char *inet_net_ntop_ipv6(const u_char *src, int bits,
      59             :                                 char *dst, size_t size);
      60             : 
      61             : 
      62             : /*
      63             :  * char *
      64             :  * pg_inet_net_ntop(af, src, bits, dst, size)
      65             :  *  convert host/network address from network to presentation format.
      66             :  *  "src"'s size is determined from its "af".
      67             :  * return:
      68             :  *  pointer to dst, or NULL if an error occurred (check errno).
      69             :  * note:
      70             :  *  192.5.5.1/28 has a nonzero host part, which means it isn't a network
      71             :  *  as called for by pg_inet_net_pton() but it can be a host address with
      72             :  *  an included netmask.
      73             :  * author:
      74             :  *  Paul Vixie (ISC), October 1998
      75             :  */
      76             : char *
      77        6486 : pg_inet_net_ntop(int af, const void *src, int bits, char *dst, size_t size)
      78             : {
      79             :     /*
      80             :      * We need to cover both the address family constants used by the PG inet
      81             :      * type (PGSQL_AF_INET and PGSQL_AF_INET6) and those used by the system
      82             :      * libraries (AF_INET and AF_INET6).  We can safely assume PGSQL_AF_INET
      83             :      * == AF_INET, but the INET6 constants are very likely to be different. If
      84             :      * AF_INET6 isn't defined, silently ignore it.
      85             :      */
      86        6486 :     switch (af)
      87             :     {
      88             :         case PGSQL_AF_INET:
      89        5010 :             return (inet_net_ntop_ipv4(src, bits, dst, size));
      90             :         case PGSQL_AF_INET6:
      91             : #if defined(AF_INET6) && AF_INET6 != PGSQL_AF_INET6
      92             :         case AF_INET6:
      93             : #endif
      94        1476 :             return (inet_net_ntop_ipv6(src, bits, dst, size));
      95             :         default:
      96           0 :             errno = EAFNOSUPPORT;
      97           0 :             return (NULL);
      98             :     }
      99             : }
     100             : 
     101             : /*
     102             :  * static char *
     103             :  * inet_net_ntop_ipv4(src, bits, dst, size)
     104             :  *  convert IPv4 network address from network to presentation format.
     105             :  *  "src"'s size is determined from its "af".
     106             :  * return:
     107             :  *  pointer to dst, or NULL if an error occurred (check errno).
     108             :  * note:
     109             :  *  network byte order assumed.  this means 192.5.5.240/28 has
     110             :  *  0b11110000 in its fourth octet.
     111             :  * author:
     112             :  *  Paul Vixie (ISC), October 1998
     113             :  */
     114             : static char *
     115        5010 : inet_net_ntop_ipv4(const u_char *src, int bits, char *dst, size_t size)
     116             : {
     117        5010 :     char       *odst = dst;
     118             :     char       *t;
     119        5010 :     int         len = 4;
     120             :     int         b;
     121             : 
     122        5010 :     if (bits < 0 || bits > 32)
     123             :     {
     124           0 :         errno = EINVAL;
     125           0 :         return (NULL);
     126             :     }
     127             : 
     128             :     /* Always format all four octets, regardless of mask length. */
     129       25050 :     for (b = len; b > 0; b--)
     130             :     {
     131       20040 :         if (size <= sizeof ".255")
     132           0 :             goto emsgsize;
     133       20040 :         t = dst;
     134       20040 :         if (dst != odst)
     135       15030 :             *dst++ = '.';
     136       20040 :         dst += SPRINTF((dst, "%u", *src++));
     137       20040 :         size -= (size_t) (dst - t);
     138             :     }
     139             : 
     140             :     /* don't print masklen if 32 bits */
     141        5010 :     if (bits != 32)
     142             :     {
     143        4006 :         if (size <= sizeof "/32")
     144           0 :             goto emsgsize;
     145        4006 :         dst += SPRINTF((dst, "/%u", bits));
     146             :     }
     147             : 
     148        5010 :     return (odst);
     149             : 
     150             : emsgsize:
     151           0 :     errno = EMSGSIZE;
     152           0 :     return (NULL);
     153             : }
     154             : 
     155             : static int
     156         176 : decoct(const u_char *src, int bytes, char *dst, size_t size)
     157             : {
     158         176 :     char       *odst = dst;
     159             :     char       *t;
     160             :     int         b;
     161             : 
     162         880 :     for (b = 1; b <= bytes; b++)
     163             :     {
     164         704 :         if (size <= sizeof "255.")
     165           0 :             return (0);
     166         704 :         t = dst;
     167         704 :         dst += SPRINTF((dst, "%u", *src++));
     168         704 :         if (b != bytes)
     169             :         {
     170         528 :             *dst++ = '.';
     171         528 :             *dst = '\0';
     172             :         }
     173         704 :         size -= (size_t) (dst - t);
     174             :     }
     175         176 :     return (dst - odst);
     176             : }
     177             : 
     178             : static char *
     179        1476 : inet_net_ntop_ipv6(const u_char *src, int bits, char *dst, size_t size)
     180             : {
     181             :     /*
     182             :      * Note that int32_t and int16_t need only be "at least" large enough to
     183             :      * contain a value of the specified size.  On some systems, like Crays,
     184             :      * there is no such thing as an integer variable with 16 bits. Keep this
     185             :      * in mind if you think this function should have been coded to use
     186             :      * pointer overlays.  All the world's not a VAX.
     187             :      */
     188             :     char        tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255/128"];
     189             :     char       *tp;
     190             :     struct
     191             :     {
     192             :         int         base,
     193             :                     len;
     194             :     }           best, cur;
     195             :     u_int       words[NS_IN6ADDRSZ / NS_INT16SZ];
     196             :     int         i;
     197             : 
     198        1476 :     if ((bits < -1) || (bits > 128))
     199             :     {
     200           0 :         errno = EINVAL;
     201           0 :         return (NULL);
     202             :     }
     203             : 
     204             :     /*
     205             :      * Preprocess: Copy the input (bytewise) array into a wordwise array. Find
     206             :      * the longest run of 0x00's in src[] for :: shorthanding.
     207             :      */
     208        1476 :     memset(words, '\0', sizeof words);
     209       25092 :     for (i = 0; i < NS_IN6ADDRSZ; i++)
     210       23616 :         words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
     211        1476 :     best.base = -1;
     212        1476 :     cur.base = -1;
     213        1476 :     best.len = 0;
     214        1476 :     cur.len = 0;
     215       13284 :     for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++)
     216             :     {
     217       11808 :         if (words[i] == 0)
     218             :         {
     219        6924 :             if (cur.base == -1)
     220        1364 :                 cur.base = i, cur.len = 1;
     221             :             else
     222        5560 :                 cur.len++;
     223             :         }
     224             :         else
     225             :         {
     226        4884 :             if (cur.base != -1)
     227             :             {
     228        1256 :                 if (best.base == -1 || cur.len > best.len)
     229        1256 :                     best = cur;
     230        1256 :                 cur.base = -1;
     231             :             }
     232             :         }
     233             :     }
     234        1476 :     if (cur.base != -1)
     235             :     {
     236         108 :         if (best.base == -1 || cur.len > best.len)
     237         104 :             best = cur;
     238             :     }
     239        1476 :     if (best.base != -1 && best.len < 2)
     240          12 :         best.base = -1;
     241             : 
     242             :     /*
     243             :      * Format the result.
     244             :      */
     245        1476 :     tp = tmp;
     246       12932 :     for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++)
     247             :     {
     248             :         /* Are we inside the best run of 0x00's? */
     249       20988 :         if (best.base != -1 && i >= best.base &&
     250        9356 :             i < (best.base + best.len))
     251             :         {
     252        6908 :             if (i == best.base)
     253        1348 :                 *tp++ = ':';
     254        6908 :             continue;
     255             :         }
     256             :         /* Are we following an initial run of 0x00s or any real hex? */
     257        4724 :         if (i != 0)
     258        3768 :             *tp++ = ':';
     259             :         /* Is this address an encapsulated IPv4? */
     260        4816 :         if (i == 6 && best.base == 0 && (best.len == 6 ||
     261         184 :                                          (best.len == 7 && words[7] != 0x0001) ||
     262         164 :                                          (best.len == 5 && words[5] == 0xffff)))
     263             :         {
     264             :             int         n;
     265             : 
     266         176 :             n = decoct(src + 12, 4, tp, sizeof tmp - (tp - tmp));
     267         176 :             if (n == 0)
     268             :             {
     269           0 :                 errno = EMSGSIZE;
     270           0 :                 return (NULL);
     271             :             }
     272         176 :             tp += strlen(tp);
     273         176 :             break;
     274             :         }
     275        4548 :         tp += SPRINTF((tp, "%x", words[i]));
     276             :     }
     277             : 
     278             :     /* Was it a trailing run of 0x00's? */
     279        1476 :     if (best.base != -1 && (best.base + best.len) ==
     280             :         (NS_IN6ADDRSZ / NS_INT16SZ))
     281          96 :         *tp++ = ':';
     282        1476 :     *tp = '\0';
     283             : 
     284        1476 :     if (bits != -1 && bits != 128)
     285         528 :         tp += SPRINTF((tp, "/%u", bits));
     286             : 
     287             :     /*
     288             :      * Check for overflow, copy, and we're done.
     289             :      */
     290        1476 :     if ((size_t) (tp - tmp) > size)
     291             :     {
     292           0 :         errno = EMSGSIZE;
     293           0 :         return (NULL);
     294             :     }
     295        1476 :     strcpy(dst, tmp);
     296        1476 :     return (dst);
     297             : }

Generated by: LCOV version 1.13