Changeset 0c2d9bb in mainline for uspace/lib/c/generic/inet/addr.c


Ignore:
Timestamp:
2013-12-25T22:54:29Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b51cf2c
Parents:
f7a33de (diff), ac36aed (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/inet/addr.c

    rf7a33de r0c2d9bb  
    3333 */
    3434
     35#include <assert.h>
    3536#include <errno.h>
    3637#include <unistd.h>
    … …  
    4849#endif
    4950
     51const addr32_t addr32_broadcast_all_hosts = 0xffffffff;
     52
    5053const addr48_t addr48_broadcast = {
    5154        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
    … …  
    5760
    5861static const inet_addr_t inet_addr_any_addr = {
    59         .family = AF_INET,
     62        .version = ip_v4,
    6063        .addr = 0
    6164};
    6265
    6366static const inet_addr_t inet_addr_any_addr6 = {
    64         .family = AF_INET6,
     67        .version = ip_v6,
    6568        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6669};
    … …  
    7679}
    7780
     81/** Compare addr48.
     82  *
     83  * @return Non-zero if equal, zero if not equal.
     84  */
    7885int addr48_compare(const addr48_t a, const addr48_t b)
    7986{
    80         return memcmp(a, b, 6);
    81 }
    82 
     87        return memcmp(a, b, 6) == 0;
     88}
     89
     90/** Compare addr128.
     91  *
     92  * @return Non-zero if equal, zero if not equal.
     93  */
    8394int addr128_compare(const addr128_t a, const addr128_t b)
    8495{
    85         return memcmp(a, b, 16);
     96        return memcmp(a, b, 16) == 0;
    8697}
    8798
    … …  
    100111void host2addr128_t_be(const addr128_t host, addr128_t be)
    101112{
    102 #ifdef __BE__
    103113        memcpy(be, host, 16);
    104 #else
    105         be[0] = host[15];
    106         be[1] = host[14];
    107         be[2] = host[13];
    108         be[3] = host[12];
    109         be[4] = host[11];
    110         be[5] = host[10];
    111         be[6] = host[9];
    112         be[7] = host[8];
    113         be[8] = host[7];
    114         be[9] = host[6];
    115         be[10] = host[5];
    116         be[11] = host[4];
    117         be[12] = host[3];
    118         be[13] = host[2];
    119         be[14] = host[1];
    120         be[15] = host[0];
    121 #endif
    122114}
    123115
    124116void addr128_t_be2host(const addr128_t be, addr128_t host)
    125117{
    126 #ifdef __BE__
    127118        memcpy(host, be, 16);
    128 #else
    129         host[0] = be[15];
    130         host[1] = be[14];
    131         host[2] = be[13];
    132         host[3] = be[12];
    133         host[4] = be[11];
    134         host[5] = be[10];
    135         host[6] = be[9];
    136         host[7] = be[8];
    137         host[8] = be[7];
    138         host[9] = be[6];
    139         host[10] = be[5];
    140         host[11] = be[4];
    141         host[12] = be[3];
    142         host[13] = be[2];
    143         host[14] = be[1];
    144         host[15] = be[0];
    145 #endif
    146119}
    147120
    148121void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    149122{
    150         addr->family = AF_INET;
     123        addr->version = ip_v4;
    151124        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    152125            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    156129    uint8_t prefix)
    157130{
    158         naddr->family = AF_INET;
     131        naddr->version = ip_v4;
    159132        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    160133            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    165138    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    166139{
    167         addr->family = AF_INET6;
     140        addr->version = ip_v6;
    168141        addr->addr6[0] = (a >> 8) & 0xff;
    169142        addr->addr6[1] = a & 0xff;
    … …  
    187160    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    188161{
    189         naddr->family = AF_INET6;
     162        naddr->version = ip_v6;
    190163        naddr->addr6[0] = (a >> 8) & 0xff;
    191164        naddr->addr6[1] = a & 0xff;
    … …  
    207180}
    208181
    209 /** Parse network address family.
    210  *
    211  * @param text Network address in common notation.
    212  * @param af   Place to store network address family.
     182/** Determine address version.
     183 *
     184 * @param text Address in common notation.
     185 * @param af   Place to store address version.
    213186 *
    214187 * @return EOK on success, EINVAL if input is not in valid format.
    215188 *
    216189 */
    217 int inet_addr_family(const char *text, uint16_t *af)
     190static int inet_addr_version(const char *text, ip_ver_t *ver)
    218191{
    219192        char *dot = str_chr(text, '.');
    220193        if (dot != NULL) {
    221                 *af = AF_INET;
     194                *ver = ip_v4;
    222195                return EOK;
    223196        }
    224        
     197
    225198        char *collon = str_chr(text, ':');
    226199        if (collon != NULL) {
    227                 *af = AF_INET6;
     200                *ver = ip_v6;
    228201                return EOK;
    229202        }
    230        
     203
    231204        return EINVAL;
    232205}
    233206
     207static int ipver_af(ip_ver_t ver)
     208{
     209        switch (ver) {
     210        case ip_any:
     211                return AF_NONE;
     212        case ip_v4:
     213                return AF_INET;
     214        case ip_v6:
     215                return AF_INET6;
     216        default:
     217                assert(false);
     218                return EINVAL;
     219        }
     220}
     221
     222ip_ver_t ipver_from_af(int af)
     223{
     224        switch (af) {
     225        case AF_NONE:
     226                return ip_any;
     227        case AF_INET:
     228                return ip_v4;
     229        case AF_INET6:
     230                return ip_v6;
     231        default:
     232                assert(false);
     233                return EINVAL;
     234        }
     235}
     236
    234237void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    235238{
    236         addr->family = naddr->family;
     239        addr->version = naddr->version;
    237240        memcpy(addr->addr6, naddr->addr6, 16);
    238241}
    … …  
    241244    inet_naddr_t *naddr)
    242245{
    243         naddr->family = addr->family;
     246        naddr->version = addr->version;
    244247        memcpy(naddr->addr6, addr->addr6, 16);
    245248        naddr->prefix = prefix;
    … …  
    248251void inet_addr_any(inet_addr_t *addr)
    249252{
    250         addr->family = AF_NONE;
     253        addr->version = ip_any;
    251254        memset(addr->addr6, 0, 16);
    252255}
    … …  
    254257void inet_naddr_any(inet_naddr_t *naddr)
    255258{
    256         naddr->family = AF_NONE;
     259        naddr->version = ip_any;
    257260        memset(naddr->addr6, 0, 16);
    258261        naddr->prefix = 0;
    … …  
    261264int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    262265{
    263         if (a->family != b->family)
     266        if (a->version != b->version)
    264267                return 0;
    265        
    266         switch (a->family) {
    267         case AF_INET:
     268
     269        switch (a->version) {
     270        case ip_v4:
    268271                return (a->addr == b->addr);
    269         case AF_INET6:
     272        case ip_v6:
    270273                return addr128_compare(a->addr6, b->addr6);
    271274        default:
    … …  
    276279int inet_addr_is_any(const inet_addr_t *addr)
    277280{
    278         return ((addr->family == 0) ||
     281        return ((addr->version == ip_any) ||
    279282            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    280283            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    283286int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    284287{
    285         if (naddr->family != addr->family)
     288        if (naddr->version != addr->version)
    286289                return 0;
    287290       
    288         switch (naddr->family) {
    289         case AF_INET:
     291        switch (naddr->version) {
     292        case ip_v4:
    290293                return (naddr->addr == addr->addr);
    291         case AF_INET6:
     294        case ip_v6:
    292295                return addr128_compare(naddr->addr6, addr->addr6);
    293296        default:
    … …  
    298301int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    299302{
    300         if (naddr->family != addr->family)
     303        if (naddr->version != addr->version)
    301304                return 0;
    302        
    303         switch (naddr->family) {
    304         case AF_INET:
     305
     306        switch (naddr->version) {
     307        case ip_v4:
    305308                if (naddr->prefix > 32)
    306309                        return 0;
    307                
     310
    308311                addr32_t mask =
    309312                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    310313                return ((naddr->addr & mask) == (addr->addr & mask));
    311         case AF_INET6:
     314        case ip_v6:
    312315                if (naddr->prefix > 128)
    313316                        return 0;
    … …  
    350353int inet_addr_parse(const char *text, inet_addr_t *addr)
    351354{
    352         int rc = inet_addr_family(text, &addr->family);
     355        int rc = inet_addr_version(text, &addr->version);
    353356        if (rc != EOK)
    354357                return rc;
    355358       
    356359        uint8_t buf[16];
    357         rc = inet_pton(addr->family, text, buf);
     360        rc = inet_pton(ipver_af(addr->version), text, buf);
    358361        if (rc != EOK)
    359362                return rc;
    360363       
    361         switch (addr->family) {
    362         case AF_INET:
     364        switch (addr->version) {
     365        case ip_v4:
    363366                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    364367                    buf[3];
    365368                break;
    366         case AF_INET6:
     369        case ip_v6:
    367370                memcpy(addr->addr6, buf, 16);
    368371                break;
    … …  
    390393        *slash = 0;
    391394       
    392         int rc = inet_addr_family(text, &naddr->family);
     395        int rc = inet_addr_version(text, &naddr->version);
    393396        if (rc != EOK)
    394397                return rc;
    395398       
    396399        uint8_t buf[16];
    397         rc = inet_pton(naddr->family, text, buf);
     400        rc = inet_pton(ipver_af(naddr->version), text, buf);
    398401        *slash = '/';
    399402       
    … …  
    404407        uint8_t prefix;
    405408       
    406         switch (naddr->family) {
    407         case AF_INET:
     409        switch (naddr->version) {
     410        case ip_v4:
    408411                prefix = strtoul(slash, &slash, 10);
    409412                if (prefix > 32)
    … …  
    415418               
    416419                break;
    417         case AF_INET6:
     420        case ip_v6:
    418421                prefix = strtoul(slash, &slash, 10);
    419422                if (prefix > 128)
    … …  
    445448        int rc = 0;
    446449       
    447         switch (addr->family) {
    448         case AF_NONE:
     450        switch (addr->version) {
     451        case ip_any:
    449452                rc = asprintf(bufp, "none");
    450453                break;
    451         case AF_INET:
     454        case ip_v4:
    452455                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    453456                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    454457                    addr->addr & 0xff);
    455458                break;
    456         case AF_INET6:
     459        case ip_v6:
    457460                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    458461                if (*bufp == NULL)
    … …  
    485488        char prefix[INET_PREFIXSTRSIZE];
    486489       
    487         switch (naddr->family) {
    488         case AF_NONE:
     490        switch (naddr->version) {
     491        case ip_any:
    489492                rc = asprintf(bufp, "none");
    490493                break;
    491         case AF_INET:
     494        case ip_v4:
    492495                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    493496                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    495498                    naddr->addr & 0xff, naddr->prefix);
    496499                break;
    497         case AF_INET6:
     500        case ip_v6:
    498501                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    499502                if (*bufp == NULL)
    … …  
    527530}
    528531
    529 uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
    530 {
    531         switch (addr->family) {
    532         case AF_INET:
     532ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     533{
     534        switch (addr->version) {
     535        case ip_v4:
    533536                if (v4 != NULL)
    534537                        *v4 = addr->addr;
    535                
    536                 break;
    537         case AF_INET6:
     538                break;
     539        case ip_v6:
    538540                if (v6 != NULL)
    539541                        memcpy(*v6, addr->addr6, 16);
    540                
    541                 break;
    542         }
    543        
    544         return addr->family;
    545 }
    546 
    547 uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     542                break;
     543        default:
     544                assert(false);
     545                break;
     546        }
     547
     548        return addr->version;
     549}
     550
     551ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    548552    uint8_t *prefix)
    549553{
    550         switch (naddr->family) {
    551         case AF_INET:
     554        switch (naddr->version) {
     555        case ip_v4:
    552556                if (v4 != NULL)
    553557                        *v4 = naddr->addr;
    554                
    555558                if (prefix != NULL)
    556559                        *prefix = naddr->prefix;
    557                
    558                 break;
    559         case AF_INET6:
     560                break;
     561        case ip_v6:
    560562                if (v6 != NULL)
    561563                        memcpy(*v6, naddr->addr6, 16);
    562                
    563564                if (prefix != NULL)
    564565                        *prefix = naddr->prefix;
    565                
    566                 break;
    567         }
    568        
    569         return naddr->family;
     566                break;
     567        default:
     568                assert(false);
     569                break;
     570        }
     571
     572        return naddr->version;
    570573}
    571574
    572575void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    573576{
    574         addr->family = AF_INET;
     577        addr->version = ip_v4;
    575578        addr->addr = v4;
    576579}
    … …  
    578581void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    579582{
    580         naddr->family = AF_INET;
     583        naddr->version = ip_v4;
    581584        naddr->addr = v4;
    582585        naddr->prefix = prefix;
    … …  
    585588void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    586589{
    587         addr->family = AF_INET;
     590        addr->version = ip_v4;
    588591        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    589592}
    … …  
    591594void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    592595{
    593         addr->family = AF_INET6;
     596        addr->version = ip_v6;
    594597        memcpy(addr->addr6, v6, 16);
    595598}
    … …  
    597600void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    598601{
    599         naddr->family = AF_INET6;
     602        naddr->version = ip_v6;
    600603        memcpy(naddr->addr6, v6, 16);
    601604        naddr->prefix = prefix;
    … …  
    605608    inet_addr_t *addr)
    606609{
    607         addr->family = AF_INET6;
     610        addr->version = ip_v6;
    608611        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    609612}
    … …  
    612615    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    613616{
    614         switch (addr->family) {
    615         case AF_INET:
     617        switch (addr->version) {
     618        case ip_v4:
    616619                if (sockaddr_in != NULL) {
    617620                        sockaddr_in->sin_family = AF_INET;
    618621                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    619622                }
    620                
    621                 break;
    622         case AF_INET6:
     623                break;
     624        case ip_v6:
    623625                if (sockaddr_in6 != NULL) {
    624626                        sockaddr_in6->sin6_family = AF_INET6;
    625627                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    626628                }
    627                
    628                 break;
    629         }
    630        
    631         return addr->family;
     629                break;
     630        default:
     631                assert(false);
     632                break;
     633        }
     634
     635        return ipver_af(addr->version);
     636}
     637
     638int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port,
     639    sockaddr_t **nsockaddr, socklen_t *naddrlen)
     640{
     641        sockaddr_in_t *sa4;
     642        sockaddr_in6_t *sa6;
     643
     644        switch (addr->version) {
     645        case ip_v4:
     646                sa4 = calloc(1, sizeof(sockaddr_in_t));
     647                if (sa4 == NULL)
     648                        return ENOMEM;
     649
     650                sa4->sin_family = AF_INET;
     651                sa4->sin_port = host2uint16_t_be(port);
     652                sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr);
     653                if (nsockaddr != NULL)
     654                        *nsockaddr = (sockaddr_t *)sa4;
     655                if (naddrlen != NULL)
     656                        *naddrlen = sizeof(*sa4);
     657                break;
     658        case ip_v6:
     659                sa6 = calloc(1, sizeof(sockaddr_in6_t));
     660                if (sa6 == NULL)
     661                        return ENOMEM;
     662
     663                sa6->sin6_family = AF_INET6;
     664                sa6->sin6_port = host2uint16_t_be(port);
     665                host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr);
     666                if (nsockaddr != NULL)
     667                        *nsockaddr = (sockaddr_t *)sa6;
     668                if (naddrlen != NULL)
     669                        *naddrlen = sizeof(*sa6);
     670                break;
     671        default:
     672                assert(false);
     673                break;
     674        }
     675
     676        return EOK;
    632677}
    633678
Note: See TracChangeset for help on using the changeset viewer.