Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r26de91a r83781a22  
    3333 */
    3434
    35 #include <assert.h>
    3635#include <errno.h>
    3736#include <unistd.h>
    … …  
    4948#endif
    5049
    51 const addr32_t addr32_broadcast_all_hosts = 0xffffffff;
    52 
    5350const addr48_t addr48_broadcast = {
    5451        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
    … …  
    6057
    6158static const inet_addr_t inet_addr_any_addr = {
    62         .version = ip_v4,
     59        .family = AF_INET,
    6360        .addr = 0
    6461};
    6562
    6663static const inet_addr_t inet_addr_any_addr6 = {
    67         .version = ip_v6,
     64        .family = AF_INET6,
    6865        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6966};
    … …  
    7976}
    8077
    81 /** Compare addr48.
    82   *
    83   * @return Non-zero if equal, zero if not equal.
    84   */
    8578int addr48_compare(const addr48_t a, const addr48_t b)
    8679{
    87         return memcmp(a, b, 6) == 0;
    88 }
    89 
    90 /** Compare addr128.
    91   *
    92   * @return Non-zero if equal, zero if not equal.
    93   */
     80        return memcmp(a, b, 6);
     81}
     82
    9483int addr128_compare(const addr128_t a, const addr128_t b)
    9584{
    96         return memcmp(a, b, 16) == 0;
     85        return memcmp(a, b, 16);
    9786}
    9887
    … …  
    111100void host2addr128_t_be(const addr128_t host, addr128_t be)
    112101{
     102#ifdef __BE__
    113103        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
    114122}
    115123
    116124void addr128_t_be2host(const addr128_t be, addr128_t host)
    117125{
     126#ifdef __BE__
    118127        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
    119146}
    120147
    121148void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    122149{
    123         addr->version = ip_v4;
     150        addr->family = AF_INET;
    124151        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    125152            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    129156    uint8_t prefix)
    130157{
    131         naddr->version = ip_v4;
     158        naddr->family = AF_INET;
    132159        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    133160            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    138165    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    139166{
    140         addr->version = ip_v6;
     167        addr->family = AF_INET6;
    141168        addr->addr6[0] = (a >> 8) & 0xff;
    142169        addr->addr6[1] = a & 0xff;
    … …  
    160187    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    161188{
    162         naddr->version = ip_v6;
     189        naddr->family = AF_INET6;
    163190        naddr->addr6[0] = (a >> 8) & 0xff;
    164191        naddr->addr6[1] = a & 0xff;
    … …  
    180207}
    181208
    182 /** Determine address version.
    183  *
    184  * @param text Address in common notation.
    185  * @param af   Place to store address version.
     209/** Parse network address family.
     210 *
     211 * @param text Network address in common notation.
     212 * @param af   Place to store network address family.
    186213 *
    187214 * @return EOK on success, EINVAL if input is not in valid format.
    188215 *
    189216 */
    190 static int inet_addr_version(const char *text, ip_ver_t *ver)
     217int inet_addr_family(const char *text, uint16_t *af)
    191218{
    192219        char *dot = str_chr(text, '.');
    193220        if (dot != NULL) {
    194                 *ver = ip_v4;
     221                *af = AF_INET;
    195222                return EOK;
    196223        }
    197 
     224       
    198225        char *collon = str_chr(text, ':');
    199226        if (collon != NULL) {
    200                 *ver = ip_v6;
     227                *af = AF_INET6;
    201228                return EOK;
    202229        }
    203 
     230       
    204231        return EINVAL;
    205232}
    206233
    207 static 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 
    222 ip_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 
    237234void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    238235{
    239         addr->version = naddr->version;
     236        addr->family = naddr->family;
    240237        memcpy(addr->addr6, naddr->addr6, 16);
    241238}
    … …  
    244241    inet_naddr_t *naddr)
    245242{
    246         naddr->version = addr->version;
     243        naddr->family = addr->family;
    247244        memcpy(naddr->addr6, addr->addr6, 16);
    248245        naddr->prefix = prefix;
    … …  
    251248void inet_addr_any(inet_addr_t *addr)
    252249{
    253         addr->version = ip_any;
     250        addr->family = AF_NONE;
    254251        memset(addr->addr6, 0, 16);
    255252}
    … …  
    257254void inet_naddr_any(inet_naddr_t *naddr)
    258255{
    259         naddr->version = ip_any;
     256        naddr->family = AF_NONE;
    260257        memset(naddr->addr6, 0, 16);
    261258        naddr->prefix = 0;
    … …  
    264261int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    265262{
    266         if (a->version != b->version)
     263        if (a->family != b->family)
    267264                return 0;
    268 
    269         switch (a->version) {
    270         case ip_v4:
     265       
     266        switch (a->family) {
     267        case AF_INET:
    271268                return (a->addr == b->addr);
    272         case ip_v6:
     269        case AF_INET6:
    273270                return addr128_compare(a->addr6, b->addr6);
    274271        default:
    … …  
    279276int inet_addr_is_any(const inet_addr_t *addr)
    280277{
    281         return ((addr->version == ip_any) ||
     278        return ((addr->family == 0) ||
    282279            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    283280            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    286283int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    287284{
    288         if (naddr->version != addr->version)
     285        if (naddr->family != addr->family)
    289286                return 0;
    290287       
    291         switch (naddr->version) {
    292         case ip_v4:
     288        switch (naddr->family) {
     289        case AF_INET:
    293290                return (naddr->addr == addr->addr);
    294         case ip_v6:
     291        case AF_INET6:
    295292                return addr128_compare(naddr->addr6, addr->addr6);
    296293        default:
    … …  
    301298int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    302299{
    303         if (naddr->version != addr->version)
     300        if (naddr->family != addr->family)
    304301                return 0;
    305 
    306         switch (naddr->version) {
    307         case ip_v4:
     302       
     303        switch (naddr->family) {
     304        case AF_INET:
    308305                if (naddr->prefix > 32)
    309306                        return 0;
    310 
     307               
    311308                addr32_t mask =
    312309                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    313310                return ((naddr->addr & mask) == (addr->addr & mask));
    314         case ip_v6:
     311        case AF_INET6:
    315312                if (naddr->prefix > 128)
    316313                        return 0;
    … …  
    353350int inet_addr_parse(const char *text, inet_addr_t *addr)
    354351{
    355         int rc = inet_addr_version(text, &addr->version);
     352        int rc = inet_addr_family(text, &addr->family);
    356353        if (rc != EOK)
    357354                return rc;
    358355       
    359356        uint8_t buf[16];
    360         rc = inet_pton(ipver_af(addr->version), text, buf);
     357        rc = inet_pton(addr->family, text, buf);
    361358        if (rc != EOK)
    362359                return rc;
    363360       
    364         switch (addr->version) {
    365         case ip_v4:
     361        switch (addr->family) {
     362        case AF_INET:
    366363                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    367364                    buf[3];
    368365                break;
    369         case ip_v6:
     366        case AF_INET6:
    370367                memcpy(addr->addr6, buf, 16);
    371368                break;
    … …  
    393390        *slash = 0;
    394391       
    395         int rc = inet_addr_version(text, &naddr->version);
     392        int rc = inet_addr_family(text, &naddr->family);
    396393        if (rc != EOK)
    397394                return rc;
    398395       
    399396        uint8_t buf[16];
    400         rc = inet_pton(ipver_af(naddr->version), text, buf);
     397        rc = inet_pton(naddr->family, text, buf);
    401398        *slash = '/';
    402399       
    … …  
    407404        uint8_t prefix;
    408405       
    409         switch (naddr->version) {
    410         case ip_v4:
     406        switch (naddr->family) {
     407        case AF_INET:
    411408                prefix = strtoul(slash, &slash, 10);
    412409                if (prefix > 32)
    … …  
    418415               
    419416                break;
    420         case ip_v6:
     417        case AF_INET6:
    421418                prefix = strtoul(slash, &slash, 10);
    422419                if (prefix > 128)
    … …  
    448445        int rc = 0;
    449446       
    450         switch (addr->version) {
    451         case ip_any:
     447        switch (addr->family) {
     448        case AF_NONE:
    452449                rc = asprintf(bufp, "none");
    453450                break;
    454         case ip_v4:
     451        case AF_INET:
    455452                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    456453                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    457454                    addr->addr & 0xff);
    458455                break;
    459         case ip_v6:
     456        case AF_INET6:
    460457                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    461458                if (*bufp == NULL)
    … …  
    488485        char prefix[INET_PREFIXSTRSIZE];
    489486       
    490         switch (naddr->version) {
    491         case ip_any:
     487        switch (naddr->family) {
     488        case AF_NONE:
    492489                rc = asprintf(bufp, "none");
    493490                break;
    494         case ip_v4:
     491        case AF_INET:
    495492                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    496493                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    498495                    naddr->addr & 0xff, naddr->prefix);
    499496                break;
    500         case ip_v6:
     497        case AF_INET6:
    501498                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    502499                if (*bufp == NULL)
    … …  
    530527}
    531528
    532 ip_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:
     529uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     530{
     531        switch (addr->family) {
     532        case AF_INET:
    536533                if (v4 != NULL)
    537534                        *v4 = addr->addr;
    538                 break;
    539         case ip_v6:
     535               
     536                break;
     537        case AF_INET6:
    540538                if (v6 != NULL)
    541539                        memcpy(*v6, addr->addr6, 16);
    542                 break;
    543         default:
    544                 assert(false);
    545                 break;
    546         }
    547 
    548         return addr->version;
    549 }
    550 
    551 ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     540               
     541                break;
     542        }
     543       
     544        return addr->family;
     545}
     546
     547uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    552548    uint8_t *prefix)
    553549{
    554         switch (naddr->version) {
    555         case ip_v4:
     550        switch (naddr->family) {
     551        case AF_INET:
    556552                if (v4 != NULL)
    557553                        *v4 = naddr->addr;
     554               
    558555                if (prefix != NULL)
    559556                        *prefix = naddr->prefix;
    560                 break;
    561         case ip_v6:
     557               
     558                break;
     559        case AF_INET6:
    562560                if (v6 != NULL)
    563561                        memcpy(*v6, naddr->addr6, 16);
     562               
    564563                if (prefix != NULL)
    565564                        *prefix = naddr->prefix;
    566                 break;
    567         default:
    568                 assert(false);
    569                 break;
    570         }
    571 
    572         return naddr->version;
     565               
     566                break;
     567        }
     568       
     569        return naddr->family;
    573570}
    574571
    575572void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    576573{
    577         addr->version = ip_v4;
     574        addr->family = AF_INET;
    578575        addr->addr = v4;
    579576}
    … …  
    581578void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    582579{
    583         naddr->version = ip_v4;
     580        naddr->family = AF_INET;
    584581        naddr->addr = v4;
    585582        naddr->prefix = prefix;
    … …  
    588585void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    589586{
    590         addr->version = ip_v4;
     587        addr->family = AF_INET;
    591588        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    592589}
    … …  
    594591void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    595592{
    596         addr->version = ip_v6;
     593        addr->family = AF_INET6;
    597594        memcpy(addr->addr6, v6, 16);
    598595}
    … …  
    600597void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    601598{
    602         naddr->version = ip_v6;
     599        naddr->family = AF_INET6;
    603600        memcpy(naddr->addr6, v6, 16);
    604601        naddr->prefix = prefix;
    … …  
    608605    inet_addr_t *addr)
    609606{
    610         addr->version = ip_v6;
     607        addr->family = AF_INET6;
    611608        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    612609}
    … …  
    615612    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    616613{
    617         switch (addr->version) {
    618         case ip_v4:
     614        switch (addr->family) {
     615        case AF_INET:
    619616                if (sockaddr_in != NULL) {
    620617                        sockaddr_in->sin_family = AF_INET;
    621618                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    622619                }
    623                 break;
    624         case ip_v6:
     620               
     621                break;
     622        case AF_INET6:
    625623                if (sockaddr_in6 != NULL) {
    626624                        sockaddr_in6->sin6_family = AF_INET6;
    627625                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    628626                }
    629                 break;
    630         default:
    631                 assert(false);
    632                 break;
    633         }
    634 
    635         return ipver_af(addr->version);
    636 }
    637 
    638 int 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;
     627               
     628                break;
     629        }
     630       
     631        return addr->family;
    677632}
    678633
Note: See TracChangeset for help on using the changeset viewer.