[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.3.6.1

1.3.6.1 ! wrstuden    1: /*     $NetBSD: inet_ntop.c,v 1.3.4.2 2007/05/17 21:25:14 jdc 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.3.6.1 ! wrstuden   23: static const char rcsid[] = "Id: inet_ntop.c,v 1.3.18.2 2005/11/03 23:02:22 marka Exp";
1.2       christos   24: #else
1.3.6.1 ! wrstuden   25: __RCSID("$NetBSD: inet_ntop.c,v 1.3.4.2 2007/05/17 21:25:14 jdc 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.3.6.1 ! wrstuden   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 *
                     69: inet_ntop(af, src, dst, size)
                     70:        int af;
                     71:        const void *src;
                     72:        char *dst;
1.2       christos   73:        socklen_t size;
1.1       christos   74: {
1.2       christos   75:
                     76:        _DIAGASSERT(src != NULL);
                     77:        _DIAGASSERT(dst != NULL);
                     78:
1.1       christos   79:        switch (af) {
                     80:        case AF_INET:
                     81:                return (inet_ntop4(src, dst, size));
                     82:        case AF_INET6:
                     83:                return (inet_ntop6(src, dst, size));
                     84:        default:
                     85:                errno = EAFNOSUPPORT;
                     86:                return (NULL);
                     87:        }
                     88:        /* NOTREACHED */
                     89: }
                     90:
                     91: /* const char *
                     92:  * inet_ntop4(src, dst, size)
1.2       christos   93:  *     format an IPv4 address, more or less like inet_ntoa()
1.1       christos   94:  * return:
                     95:  *     `dst' (as a const)
                     96:  * notes:
                     97:  *     (1) uses no statics
                     98:  *     (2) takes a u_char* not an in_addr as input
                     99:  * author:
                    100:  *     Paul Vixie, 1996.
                    101:  */
                    102: static const char *
                    103: inet_ntop4(src, dst, size)
                    104:        const u_char *src;
                    105:        char *dst;
1.2       christos  106:        socklen_t size;
1.1       christos  107: {
                    108:        char tmp[sizeof "255.255.255.255"];
1.2       christos  109:        int l;
                    110:
                    111:        _DIAGASSERT(src != NULL);
                    112:        _DIAGASSERT(dst != NULL);
1.1       christos  113:
1.2       christos  114:        l = snprintf(tmp, sizeof(tmp), "%u.%u.%u.%u",
                    115:            src[0], src[1], src[2], src[3]);
                    116:        if (l <= 0 || (socklen_t) l >= size) {
1.1       christos  117:                errno = ENOSPC;
                    118:                return (NULL);
                    119:        }
1.2       christos  120:        strlcpy(dst, tmp, size);
1.1       christos  121:        return (dst);
                    122: }
                    123:
                    124: /* const char *
                    125:  * inet_ntop6(src, dst, size)
                    126:  *     convert IPv6 binary address into presentation (printable) format
                    127:  * author:
                    128:  *     Paul Vixie, 1996.
                    129:  */
                    130: static const char *
                    131: inet_ntop6(src, dst, size)
                    132:        const u_char *src;
                    133:        char *dst;
1.2       christos  134:        socklen_t size;
1.1       christos  135: {
                    136:        /*
                    137:         * Note that int32_t and int16_t need only be "at least" large enough
                    138:         * to contain a value of the specified size.  On some systems, like
                    139:         * Crays, there is no such thing as an integer variable with 16 bits.
                    140:         * Keep this in mind if you think this function should have been coded
                    141:         * to use pointer overlays.  All the world's not a VAX.
                    142:         */
1.2       christos  143:        char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
                    144:        char *tp, *ep;
1.1       christos  145:        struct { int base, len; } best, cur;
                    146:        u_int words[NS_IN6ADDRSZ / NS_INT16SZ];
                    147:        int i;
1.2       christos  148:        int advance;
                    149:
                    150:        _DIAGASSERT(src != NULL);
                    151:        _DIAGASSERT(dst != NULL);
1.1       christos  152:
                    153:        /*
                    154:         * Preprocess:
                    155:         *      Copy the input (bytewise) array into a wordwise array.
                    156:         *      Find the longest run of 0x00's in src[] for :: shorthanding.
                    157:         */
                    158:        memset(words, '\0', sizeof words);
                    159:        for (i = 0; i < NS_IN6ADDRSZ; i++)
                    160:                words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
                    161:        best.base = -1;
1.3.6.1 ! wrstuden  162:        best.len = 0;
1.1       christos  163:        cur.base = -1;
1.3.6.1 ! wrstuden  164:        cur.len = 0;
1.1       christos  165:        for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
                    166:                if (words[i] == 0) {
                    167:                        if (cur.base == -1)
                    168:                                cur.base = i, cur.len = 1;
                    169:                        else
                    170:                                cur.len++;
                    171:                } else {
                    172:                        if (cur.base != -1) {
                    173:                                if (best.base == -1 || cur.len > best.len)
                    174:                                        best = cur;
                    175:                                cur.base = -1;
                    176:                        }
                    177:                }
                    178:        }
                    179:        if (cur.base != -1) {
                    180:                if (best.base == -1 || cur.len > best.len)
                    181:                        best = cur;
                    182:        }
                    183:        if (best.base != -1 && best.len < 2)
                    184:                best.base = -1;
                    185:
                    186:        /*
                    187:         * Format the result.
                    188:         */
                    189:        tp = tmp;
1.2       christos  190:        ep = tmp + sizeof(tmp);
1.1       christos  191:        for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
                    192:                /* Are we inside the best run of 0x00's? */
                    193:                if (best.base != -1 && i >= best.base &&
                    194:                    i < (best.base + best.len)) {
                    195:                        if (i == best.base)
                    196:                                *tp++ = ':';
                    197:                        continue;
                    198:                }
                    199:                /* Are we following an initial run of 0x00s or any real hex? */
1.2       christos  200:                if (i != 0) {
                    201:                        if (tp + 1 >= ep)
                    202:                                return (NULL);
1.1       christos  203:                        *tp++ = ':';
1.2       christos  204:                }
1.1       christos  205:                /* Is this address an encapsulated IPv4? */
1.2       christos  206:                if (i == 6 && best.base == 0 &&
                    207:                    (best.len == 6 ||
1.1       christos  208:                    (best.len == 7 && words[7] != 0x0001) ||
                    209:                    (best.len == 5 && words[5] == 0xffff))) {
1.2       christos  210:                        if (!inet_ntop4(src+12, tp, (socklen_t)(ep - tp)))
1.1       christos  211:                                return (NULL);
                    212:                        tp += strlen(tp);
                    213:                        break;
                    214:                }
1.2       christos  215:                advance = snprintf(tp, (size_t)(ep - tp), "%x", words[i]);
                    216:                if (advance <= 0 || advance >= ep - tp)
                    217:                        return (NULL);
                    218:                tp += advance;
1.1       christos  219:        }
                    220:        /* Was it a trailing run of 0x00's? */
                    221:        if (best.base != -1 && (best.base + best.len) ==
1.2       christos  222:            (NS_IN6ADDRSZ / NS_INT16SZ)) {
                    223:                if (tp + 1 >= ep)
                    224:                        return (NULL);
1.1       christos  225:                *tp++ = ':';
1.2       christos  226:        }
                    227:        if (tp + 1 >= ep)
                    228:                return (NULL);
1.1       christos  229:        *tp++ = '\0';
                    230:
                    231:        /*
                    232:         * Check for overflow, copy, and we're done.
                    233:         */
                    234:        if ((size_t)(tp - tmp) > size) {
                    235:                errno = ENOSPC;
                    236:                return (NULL);
                    237:        }
1.2       christos  238:        strlcpy(dst, tmp, size);
1.1       christos  239:        return (dst);
                    240: }
1.3.6.1 ! wrstuden  241:
        !           242: /*! \file */

CVSweb <webmaster@jp.NetBSD.org>