Ignore:
Timestamp:
Feb 25, 2011, 9:26:54 PM (13 years ago)
Author:
Bruno Cornec
Message:
  • Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3
File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/2.2.9/mindi-busybox/networking/libiproute/utils.c

    r1765 r2725  
    11/* vi: set sw=4 ts=4: */
    22/*
    3  * utils.c
     3 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
    44 *
    5  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
    6  *
    7  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
     5 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
    86 *
    97 * Changes:
    108 *
    11  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
     9 * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
    1210 */
    1311
    … …  
    1614#include "inet_common.h"
    1715
    18 int get_integer(int *val, char *arg, int base)
    19 {
    20     long res;
    21     char *ptr;
    22 
    23     if (!arg || !*arg)
    24         return -1;
    25     res = strtol(arg, &ptr, base);
    26     if (!ptr || ptr == arg || *ptr || res > INT_MAX || res < INT_MIN)
    27         return -1;
    28     *val = res;
    29     return 0;
    30 }
    31 //XXX: FIXME: use some libbb function instead
    32 int get_unsigned(unsigned *val, char *arg, int base)
     16unsigned get_unsigned(char *arg, const char *errmsg)
    3317{
    3418    unsigned long res;
    3519    char *ptr;
    3620
    37     if (!arg || !*arg)
    38         return -1;
    39     res = strtoul(arg, &ptr, base);
    40     if (!ptr || ptr == arg || *ptr || res > UINT_MAX)
    41         return -1;
    42     *val = res;
    43     return 0;
    44 }
    45 
    46 int get_u32(uint32_t * val, char *arg, int base)
     21    if (*arg) {
     22        res = strtoul(arg, &ptr, 0);
     23//FIXME: "" will be accepted too, is it correct?!
     24        if (!*ptr && res <= UINT_MAX) {
     25            return res;
     26        }
     27    }
     28    invarg(arg, errmsg); /* does not return */
     29}
     30
     31uint32_t get_u32(char *arg, const char *errmsg)
    4732{
    4833    unsigned long res;
    4934    char *ptr;
    5035
    51     if (!arg || !*arg)
    52         return -1;
    53     res = strtoul(arg, &ptr, base);
    54     if (!ptr || ptr == arg || *ptr || res > 0xFFFFFFFFUL)
    55         return -1;
    56     *val = res;
    57     return 0;
    58 }
    59 
    60 int get_u16(uint16_t * val, char *arg, int base)
     36    if (*arg) {
     37        res = strtoul(arg, &ptr, 0);
     38//FIXME: "" will be accepted too, is it correct?!
     39        if (!*ptr && res <= 0xFFFFFFFFUL) {
     40            return res;
     41        }
     42    }
     43    invarg(arg, errmsg); /* does not return */
     44}
     45
     46uint16_t get_u16(char *arg, const char *errmsg)
    6147{
    6248    unsigned long res;
    6349    char *ptr;
    6450
    65     if (!arg || !*arg)
    66         return -1;
    67     res = strtoul(arg, &ptr, base);
    68     if (!ptr || ptr == arg || *ptr || res > 0xFFFF)
    69         return -1;
    70     *val = res;
    71     return 0;
    72 }
    73 
    74 int get_u8(uint8_t * val, char *arg, int base)
    75 {
    76     unsigned long res;
    77     char *ptr;
    78 
    79     if (!arg || !*arg)
    80         return -1;
    81     res = strtoul(arg, &ptr, base);
    82     if (!ptr || ptr == arg || *ptr || res > 0xFF)
    83         return -1;
    84     *val = res;
    85     return 0;
    86 }
    87 
    88 int get_s16(int16_t * val, char *arg, int base)
    89 {
    90     long res;
    91     char *ptr;
    92 
    93     if (!arg || !*arg)
    94         return -1;
    95     res = strtol(arg, &ptr, base);
    96     if (!ptr || ptr == arg || *ptr || res > 0x7FFF || res < -0x8000)
    97         return -1;
    98     *val = res;
    99     return 0;
    100 }
    101 
    102 int get_s8(int8_t * val, char *arg, int base)
    103 {
    104     long res;
    105     char *ptr;
    106 
    107     if (!arg || !*arg)
    108         return -1;
    109     res = strtol(arg, &ptr, base);
    110     if (!ptr || ptr == arg || *ptr || res > 0x7F || res < -0x80)
    111         return -1;
    112     *val = res;
    113     return 0;
    114 }
    115 
    116 int get_addr_1(inet_prefix * addr, char *name, int family)
    117 {
    118     char *cp;
    119     unsigned char *ap = (unsigned char *) addr->data;
    120     int i;
    121 
     51    if (*arg) {
     52        res = strtoul(arg, &ptr, 0);
     53//FIXME: "" will be accepted too, is it correct?!
     54        if (!*ptr && res <= 0xFFFF) {
     55            return res;
     56        }
     57    }
     58    invarg(arg, errmsg); /* does not return */
     59}
     60
     61int get_addr_1(inet_prefix *addr, char *name, int family)
     62{
    12263    memset(addr, 0, sizeof(*addr));
    12364
    124     if (strcmp(name, bb_str_default) == 0 ||
    125         strcmp(name, "all") == 0 || strcmp(name, "any") == 0) {
     65    if (strcmp(name, "default") == 0
     66     || strcmp(name, "all") == 0
     67     || strcmp(name, "any") == 0
     68    ) {
    12669        addr->family = family;
    12770        addr->bytelen = (family == AF_INET6 ? 16 : 4);
    … …  
    14487    if (family != AF_UNSPEC && family != AF_INET)
    14588        return -1;
     89    if (inet_pton(AF_INET, name, addr->data) <= 0)
     90        return -1;
    14691    addr->bytelen = 4;
    14792    addr->bitlen = -1;
    148     for (cp = name, i = 0; *cp; cp++) {
    149         if (*cp <= '9' && *cp >= '0') {
    150             ap[i] = 10 * ap[i] + (*cp - '0');
    151             continue;
    152         }
    153         if (*cp == '.' && ++i <= 3)
    154             continue;
    155         return -1;
    156     }
    157     return 0;
    158 }
    159 
    160 int get_prefix_1(inet_prefix * dst, char *arg, int family)
     93    return 0;
     94}
     95
     96static int get_prefix_1(inet_prefix *dst, char *arg, int family)
    16197{
    16298    int err;
    163     int plen;
     99    unsigned plen;
    164100    char *slash;
    165101
    166102    memset(dst, 0, sizeof(*dst));
    167103
    168     if (strcmp(arg, bb_str_default) == 0 || strcmp(arg, "any") == 0) {
     104    if (strcmp(arg, "default") == 0
     105     || strcmp(arg, "all") == 0
     106     || strcmp(arg, "any") == 0
     107    ) {
    169108        dst->family = family;
    170         dst->bytelen = 0;
    171         dst->bitlen = 0;
     109        /*dst->bytelen = 0; - done by memset */
     110        /*dst->bitlen = 0;*/
    172111        return 0;
    173112    }
    … …  
    178117    err = get_addr_1(dst, arg, family);
    179118    if (err == 0) {
    180         switch (dst->family) {
    181         case AF_INET6:
    182             dst->bitlen = 128;
    183             break;
    184         default:
    185         case AF_INET:
    186             dst->bitlen = 32;
    187         }
     119        dst->bitlen = (dst->family == AF_INET6) ? 128 : 32;
    188120        if (slash) {
    189             if (get_integer(&plen, slash + 1, 0) || plen > dst->bitlen) {
     121            inet_prefix netmask_pfx;
     122
     123            netmask_pfx.family = AF_UNSPEC;
     124            plen = bb_strtou(slash + 1, NULL, 0);
     125            if ((errno || plen > dst->bitlen)
     126             && (get_addr_1(&netmask_pfx, slash + 1, family)))
    190127                err = -1;
    191                 goto done;
     128            else if (netmask_pfx.family == AF_INET) {
     129                /* fill in prefix length of dotted quad */
     130                uint32_t mask = ntohl(netmask_pfx.data[0]);
     131                uint32_t host = ~mask;
     132
     133                /* a valid netmask must be 2^n - 1 */
     134                if (!(host & (host + 1))) {
     135                    for (plen = 0; mask; mask <<= 1)
     136                        ++plen;
     137                    if (plen <= dst->bitlen) {
     138                        dst->bitlen = plen;
     139                        /* dst->flags |= PREFIXLEN_SPECIFIED; */
     140                    } else
     141                        err = -1;
     142                } else
     143                    err = -1;
     144            } else {
     145                /* plain prefix */
     146                dst->bitlen = plen;
    192147            }
    193             dst->bitlen = plen;
    194         }
    195     }
    196  done:
     148        }
     149    }
    197150    if (slash)
    198151        *slash = '/';
    … …  
    200153}
    201154
    202 int get_addr(inet_prefix * dst, char *arg, int family)
     155int get_addr(inet_prefix *dst, char *arg, int family)
    203156{
    204157    if (family == AF_PACKET) {
    205         bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context", arg);
     158        bb_error_msg_and_die("\"%s\" may be inet %s, but it is not allowed in this context", arg, "address");
    206159    }
    207160    if (get_addr_1(dst, arg, family)) {
    208         bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
    209     }
    210     return 0;
    211 }
    212 
    213 int get_prefix(inet_prefix * dst, char *arg, int family)
     161        bb_error_msg_and_die("an %s %s is expected rather than \"%s\"", "inet", "address", arg);
     162    }
     163    return 0;
     164}
     165
     166int get_prefix(inet_prefix *dst, char *arg, int family)
    214167{
    215168    if (family == AF_PACKET) {
    216         bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context", arg);
     169        bb_error_msg_and_die("\"%s\" may be inet %s, but it is not allowed in this context", arg, "prefix");
    217170    }
    218171    if (get_prefix_1(dst, arg, family)) {
    219         bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
     172        bb_error_msg_and_die("an %s %s is expected rather than \"%s\"", "inet", "prefix", arg);
    220173    }
    221174    return 0;
    … …  
    227180
    228181    if (get_addr_1(&addr, name, AF_INET)) {
    229         bb_error_msg_and_die("an IP address is expected rather than \"%s\"", name);
     182        bb_error_msg_and_die("an %s %s is expected rather than \"%s\"", "IP", "address", name);
    230183    }
    231184    return addr.data[0];
    … …  
    252205}
    253206
    254 int inet_addr_match(inet_prefix * a, inet_prefix * b, int bits)
     207int inet_addr_match(inet_prefix *a, inet_prefix *b, int bits)
    255208{
    256209    uint32_t *a1 = a->data;
    257210    uint32_t *a2 = b->data;
    258     int words = bits >> 0x05;
     211    int words = bits >> 5;
    259212
    260213    bits &= 0x1f;
    … …  
    280233}
    281234
    282 const char *rt_addr_n2a(int af, int ATTRIBUTE_UNUSED len,
     235const char *rt_addr_n2a(int af,
    283236        void *addr, char *buf, int buflen)
    284237{
    … …  
    292245}
    293246
    294 
     247#ifdef RESOLVE_HOSTNAMES
    295248const char *format_host(int af, int len, void *addr, char *buf, int buflen)
    296249{
    297 #ifdef RESOLVE_HOSTNAMES
    298250    if (resolve_hosts) {
    299251        struct hostent *h_ent;
    … …  
    318270        }
    319271    }
     272    return rt_addr_n2a(af, addr, buf, buflen);
     273}
    320274#endif
    321     return rt_addr_n2a(af, len, addr, buf, buflen);
    322 }
Note: See TracChangeset for help on using the changeset viewer.