[BACK]Return to inet_ntop.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / inet

Annotation of src/lib/libc/inet/inet_ntop.c, Revision 1.12

1.12    ! lukem       1: /*     $NetBSD: inet_ntop.c,v 1.11 2014/02/10 16:30:54 christos Exp $  */
1.1       christos    2:
                      3: /*
                      4:  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
                      5:  * Copyright (c) 1996-1999 by Internet Software Consortium.
                      6:  *
                      7:  * Permission to use, copy, modify, and distribute this software for any
                      8:  * purpose with or without fee is hereby granted, provided that the above
                      9:  * copyright notice and this permission notice appear in all copies.
                     10:  *
                     11:  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
                     12:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     13:  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
                     14:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     15:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     16:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
                     17:  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     18:  */
                     19:
1.2       christos   20: #include <sys/cdefs.h>
1.1       christos   21: #if defined(LIBC_SCCS) && !defined(lint)
1.2       christos   22: #if 0
1.6       christos   23: static const char rcsid[] = "Id: inet_ntop.c,v 1.5 2005/11/03 22:59:52 marka Exp";
1.2       christos   24: #else
1.12    ! lukem      25: __RCSID("$NetBSD: inet_ntop.c,v 1.11 2014/02/10 16:30:54 christos Exp $");
1.2       christos   26: #endif
1.1       christos   27: #endif /* LIBC_SCCS and not lint */
                     28:
                     29: #include "port_before.h"
                     30:
1.2       christos   31: #include "namespace.h"
1.1       christos   32: #include <sys/param.h>
                     33: #include <sys/types.h>
                     34: #include <sys/socket.h>
                     35:
                     36: #include <netinet/in.h>
                     37: #include <arpa/inet.h>
                     38: #include <arpa/nameser.h>
                     39:
1.2       christos   40: #include <assert.h>
1.1       christos   41: #include <errno.h>
                     42: #include <stdio.h>
1.2       christos   43: #include <stdlib.h>
1.1       christos   44: #include <string.h>
                     45:
                     46: #include "port_after.h"
                     47:
1.2       christos   48: #ifdef __weak_alias
                     49: __weak_alias(inet_ntop,_inet_ntop)
1.1       christos   50: #endif
                     51:
1.4       christos   52: /*%
1.1       christos   53:  * WARNING: Don't even consider trying to compile this on a system where
                     54:  * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
                     55:  */
                     56:
1.2       christos   57: static const char *inet_ntop4(const u_char *src, char *dst, socklen_t size);
                     58: static const char *inet_ntop6(const u_char *src, char *dst, socklen_t size);
1.1       christos   59:
                     60: /* char *
                     61:  * inet_ntop(af, src, dst, size)
                     62:  *     convert a network format address to presentation format.
                     63:  * return:
                     64:  *     pointer to presentation format address (`dst'), or NULL (see errno).
                     65:  * author:
                     66:  *     Paul Vixie, 1996.
                     67:  */
                     68: const char *
1.9       matt       69: inet_ntop(int af, const void *src, char *dst, socklen_t size)
1.1       christos   70: {
1.2       christos   71:
                     72:        _DIAGASSERT(src != NULL);
                     73:        _DIAGASSERT(dst != NULL);
                     74:
1.1       christos   75:        switch (af) {
                     76:        case AF_INET:
1.11      christos   77:                return inet_ntop4(src, dst, size);
1.1       christos   78:        case AF_INET6:
1.11      christos   79:                return inet_ntop6(src, dst, size);
1.1       christos   80:        default:
                     81:                errno = EAFNOSUPPORT;
1.11      christos   82:                return NULL;
1.1       christos   83:        }
                     84:        /* NOTREACHED */
                     85: }
                     86:
                     87: /* const char *
                     88:  * inet_ntop4(src, dst, size)
1.2       christos   89:  *     format an IPv4 address, more or less like inet_ntoa()
1.1       christos   90:  * return:
                     91:  *     `dst' (as a const)
                     92:  * notes:
                     93:  *     (1) uses no statics
                     94:  *     (2) takes a u_char* not an in_addr as input
                     95:  * author:
                     96:  *     Paul Vixie, 1996.
                     97:  */
                     98: static const char *
1.9       matt       99: inet_ntop4(const u_char *src, char *dst, socklen_t size)
1.1       christos  100: {
                    101:        char tmp[sizeof "255.255.255.255"];
1.2       christos  102:        int l;
                    103:
                    104:        _DIAGASSERT(src != NULL);
                    105:        _DIAGASSERT(dst != NULL);
1.1       christos  106:
1.2       christos  107:        l = snprintf(tmp, sizeof(tmp), "%u.%u.%u.%u",
                    108:            src[0], src[1], src[2], src[3]);
1.12    ! lukem     109:        if (l <= 0 || (socklen_t) l >= size) {
        !           110:                errno = ENOSPC;
1.11      christos  111:                return NULL;
1.12    ! lukem     112:        }
1.2       christos  113:        strlcpy(dst, tmp, size);
1.11      christos  114:        return dst;
1.1       christos  115: }
                    116:
                    117: /* const char *
                    118:  * inet_ntop6(src, dst, size)
                    119:  *     convert IPv6 binary address into presentation (printable) format
                    120:  * author:
                    121:  *     Paul Vixie, 1996.
                    122:  */
                    123: static const char *
1.9       matt      124: inet_ntop6(const u_char *src, char *dst, socklen_t size)
1.1       christos  125: {
                    126:        /*
                    127:         * Note that int32_t and int16_t need only be "at least" large enough
                    128:         * to contain a value of the specified size.  On some systems, like
                    129:         * Crays, there is no such thing as an integer variable with 16 bits.
                    130:         * Keep this in mind if you think this function should have been coded
                    131:         * to use pointer overlays.  All the world's not a VAX.
                    132:         */
1.2       christos  133:        char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
                    134:        char *tp, *ep;
1.1       christos  135:        struct { int base, len; } best, cur;
                    136:        u_int words[NS_IN6ADDRSZ / NS_INT16SZ];
                    137:        int i;
1.2       christos  138:        int advance;
                    139:
                    140:        _DIAGASSERT(src != NULL);
                    141:        _DIAGASSERT(dst != NULL);
1.1       christos  142:
                    143:        /*
                    144:         * Preprocess:
                    145:         *      Copy the input (bytewise) array into a wordwise array.
                    146:         *      Find the longest run of 0x00's in src[] for :: shorthanding.
                    147:         */
                    148:        memset(words, '\0', sizeof words);
                    149:        for (i = 0; i < NS_IN6ADDRSZ; i++)
                    150:                words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
                    151:        best.base = -1;
1.4       christos  152:        best.len = 0;
1.1       christos  153:        cur.base = -1;
1.4       christos  154:        cur.len = 0;
1.1       christos  155:        for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
                    156:                if (words[i] == 0) {
                    157:                        if (cur.base == -1)
                    158:                                cur.base = i, cur.len = 1;
                    159:                        else
                    160:                                cur.len++;
                    161:                } else {
                    162:                        if (cur.base != -1) {
                    163:                                if (best.base == -1 || cur.len > best.len)
                    164:                                        best = cur;
                    165:                                cur.base = -1;
                    166:                        }
                    167:                }
                    168:        }
                    169:        if (cur.base != -1) {
                    170:                if (best.base == -1 || cur.len > best.len)
                    171:                        best = cur;
                    172:        }
                    173:        if (best.base != -1 && best.len < 2)
                    174:                best.base = -1;
                    175:
                    176:        /*
                    177:         * Format the result.
                    178:         */
                    179:        tp = tmp;
1.2       christos  180:        ep = tmp + sizeof(tmp);
1.1       christos  181:        for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
                    182:                /* Are we inside the best run of 0x00's? */
                    183:                if (best.base != -1 && i >= best.base &&
                    184:                    i < (best.base + best.len)) {
                    185:                        if (i == best.base)
                    186:                                *tp++ = ':';
                    187:                        continue;
                    188:                }
                    189:                /* Are we following an initial run of 0x00s or any real hex? */
1.2       christos  190:                if (i != 0) {
                    191:                        if (tp + 1 >= ep)
1.10      christos  192:                                goto out;
1.1       christos  193:                        *tp++ = ':';
1.2       christos  194:                }
1.1       christos  195:                /* Is this address an encapsulated IPv4? */
1.2       christos  196:                if (i == 6 && best.base == 0 &&
                    197:                    (best.len == 6 ||
1.1       christos  198:                    (best.len == 7 && words[7] != 0x0001) ||
                    199:                    (best.len == 5 && words[5] == 0xffff))) {
1.10      christos  200:                        if (!inet_ntop4(src + 12, tp, (socklen_t)(ep - tp)))
                    201:                                goto out;
1.1       christos  202:                        tp += strlen(tp);
                    203:                        break;
                    204:                }
1.2       christos  205:                advance = snprintf(tp, (size_t)(ep - tp), "%x", words[i]);
                    206:                if (advance <= 0 || advance >= ep - tp)
1.10      christos  207:                        goto out;
1.2       christos  208:                tp += advance;
1.1       christos  209:        }
                    210:        /* Was it a trailing run of 0x00's? */
                    211:        if (best.base != -1 && (best.base + best.len) ==
1.2       christos  212:            (NS_IN6ADDRSZ / NS_INT16SZ)) {
                    213:                if (tp + 1 >= ep)
1.10      christos  214:                        goto out;
1.1       christos  215:                *tp++ = ':';
1.2       christos  216:        }
                    217:        if (tp + 1 >= ep)
1.10      christos  218:                goto out;
1.1       christos  219:        *tp++ = '\0';
                    220:
                    221:        /*
                    222:         * Check for overflow, copy, and we're done.
                    223:         */
1.10      christos  224:        if ((size_t)(tp - tmp) > size)
                    225:                goto out;
1.2       christos  226:        strlcpy(dst, tmp, size);
1.11      christos  227:        return dst;
1.10      christos  228: out:
                    229:        errno = ENOSPC;
                    230:        return NULL;
1.1       christos  231: }
1.4       christos  232:
                    233: /*! \file */

CVSweb <webmaster@jp.NetBSD.org>