Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r26de91a r695b6ff  
    3333 */
    3434
    35 #include <assert.h>
    3635#include <errno.h>
    3736#include <unistd.h>
    … …  
    6059
    6160static const inet_addr_t inet_addr_any_addr = {
    62         .version = ip_v4,
     61        .family = AF_INET,
    6362        .addr = 0
    6463};
    6564
    6665static const inet_addr_t inet_addr_any_addr6 = {
    67         .version = ip_v6,
     66        .family = AF_INET6,
    6867        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6968};
    … …  
    7978}
    8079
    81 /** Compare addr48.
    82   *
    83   * @return Non-zero if equal, zero if not equal.
    84   */
    8580int addr48_compare(const addr48_t a, const addr48_t b)
    8681{
    87         return memcmp(a, b, 6) == 0;
    88 }
    89 
    90 /** Compare addr128.
    91   *
    92   * @return Non-zero if equal, zero if not equal.
    93   */
     82        return memcmp(a, b, 6);
     83}
     84
    9485int addr128_compare(const addr128_t a, const addr128_t b)
    9586{
    96         return memcmp(a, b, 16) == 0;
     87        return memcmp(a, b, 16);
    9788}
    9889
    … …  
    111102void host2addr128_t_be(const addr128_t host, addr128_t be)
    112103{
     104#ifdef __BE__
    113105        memcpy(be, host, 16);
     106#else
     107        be[0] = host[15];
     108        be[1] = host[14];
     109        be[2] = host[13];
     110        be[3] = host[12];
     111        be[4] = host[11];
     112        be[5] = host[10];
     113        be[6] = host[9];
     114        be[7] = host[8];
     115        be[8] = host[7];
     116        be[9] = host[6];
     117        be[10] = host[5];
     118        be[11] = host[4];
     119        be[12] = host[3];
     120        be[13] = host[2];
     121        be[14] = host[1];
     122        be[15] = host[0];
     123#endif
    114124}
    115125
    116126void addr128_t_be2host(const addr128_t be, addr128_t host)
    117127{
     128#ifdef __BE__
    118129        memcpy(host, be, 16);
     130#else
     131        host[0] = be[15];
     132        host[1] = be[14];
     133        host[2] = be[13];
     134        host[3] = be[12];
     135        host[4] = be[11];
     136        host[5] = be[10];
     137        host[6] = be[9];
     138        host[7] = be[8];
     139        host[8] = be[7];
     140        host[9] = be[6];
     141        host[10] = be[5];
     142        host[11] = be[4];
     143        host[12] = be[3];
     144        host[13] = be[2];
     145        host[14] = be[1];
     146        host[15] = be[0];
     147#endif
    119148}
    120149
    121150void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    122151{
    123         addr->version = ip_v4;
     152        addr->family = AF_INET;
    124153        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    125154            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    129158    uint8_t prefix)
    130159{
    131         naddr->version = ip_v4;
     160        naddr->family = AF_INET;
    132161        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    133162            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    138167    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    139168{
    140         addr->version = ip_v6;
     169        addr->family = AF_INET6;
    141170        addr->addr6[0] = (a >> 8) & 0xff;
    142171        addr->addr6[1] = a & 0xff;
    … …  
    160189    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    161190{
    162         naddr->version = ip_v6;
     191        naddr->family = AF_INET6;
    163192        naddr->addr6[0] = (a >> 8) & 0xff;
    164193        naddr->addr6[1] = a & 0xff;
    … …  
    180209}
    181210
    182 /** Determine address version.
    183  *
    184  * @param text Address in common notation.
    185  * @param af   Place to store address version.
     211/** Parse network address family.
     212 *
     213 * @param text Network address in common notation.
     214 * @param af   Place to store network address family.
    186215 *
    187216 * @return EOK on success, EINVAL if input is not in valid format.
    188217 *
    189218 */
    190 static int inet_addr_version(const char *text, ip_ver_t *ver)
     219int inet_addr_family(const char *text, uint16_t *af)
    191220{
    192221        char *dot = str_chr(text, '.');
    193222        if (dot != NULL) {
    194                 *ver = ip_v4;
     223                *af = AF_INET;
    195224                return EOK;
    196225        }
    197 
     226       
    198227        char *collon = str_chr(text, ':');
    199228        if (collon != NULL) {
    200                 *ver = ip_v6;
     229                *af = AF_INET6;
    201230                return EOK;
    202231        }
    203 
     232       
    204233        return EINVAL;
    205234}
    206235
    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 
    237236void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    238237{
    239         addr->version = naddr->version;
     238        addr->family = naddr->family;
    240239        memcpy(addr->addr6, naddr->addr6, 16);
    241240}
    … …  
    244243    inet_naddr_t *naddr)
    245244{
    246         naddr->version = addr->version;
     245        naddr->family = addr->family;
    247246        memcpy(naddr->addr6, addr->addr6, 16);
    248247        naddr->prefix = prefix;
    … …  
    251250void inet_addr_any(inet_addr_t *addr)
    252251{
    253         addr->version = ip_any;
     252        addr->family = AF_NONE;
    254253        memset(addr->addr6, 0, 16);
    255254}
    … …  
    257256void inet_naddr_any(inet_naddr_t *naddr)
    258257{
    259         naddr->version = ip_any;
     258        naddr->family = AF_NONE;
    260259        memset(naddr->addr6, 0, 16);
    261260        naddr->prefix = 0;
    … …  
    264263int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    265264{
    266         if (a->version != b->version)
     265        if (a->family != b->family)
    267266                return 0;
    268 
    269         switch (a->version) {
    270         case ip_v4:
     267       
     268        switch (a->family) {
     269        case AF_INET:
    271270                return (a->addr == b->addr);
    272         case ip_v6:
     271        case AF_INET6:
    273272                return addr128_compare(a->addr6, b->addr6);
    274273        default:
    … …  
    279278int inet_addr_is_any(const inet_addr_t *addr)
    280279{
    281         return ((addr->version == ip_any) ||
     280        return ((addr->family == 0) ||
    282281            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    283282            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    286285int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    287286{
    288         if (naddr->version != addr->version)
     287        if (naddr->family != addr->family)
    289288                return 0;
    290289       
    291         switch (naddr->version) {
    292         case ip_v4:
     290        switch (naddr->family) {
     291        case AF_INET:
    293292                return (naddr->addr == addr->addr);
    294         case ip_v6:
     293        case AF_INET6:
    295294                return addr128_compare(naddr->addr6, addr->addr6);
    296295        default:
    … …  
    301300int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    302301{
    303         if (naddr->version != addr->version)
     302        if (naddr->family != addr->family)
    304303                return 0;
    305 
    306         switch (naddr->version) {
    307         case ip_v4:
     304       
     305        switch (naddr->family) {
     306        case AF_INET:
    308307                if (naddr->prefix > 32)
    309308                        return 0;
    310 
     309               
    311310                addr32_t mask =
    312311                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    313312                return ((naddr->addr & mask) == (addr->addr & mask));
    314         case ip_v6:
     313        case AF_INET6:
    315314                if (naddr->prefix > 128)
    316315                        return 0;
    … …  
    353352int inet_addr_parse(const char *text, inet_addr_t *addr)
    354353{
    355         int rc = inet_addr_version(text, &addr->version);
     354        int rc = inet_addr_family(text, &addr->family);
    356355        if (rc != EOK)
    357356                return rc;
    358357       
    359358        uint8_t buf[16];
    360         rc = inet_pton(ipver_af(addr->version), text, buf);
     359        rc = inet_pton(addr->family, text, buf);
    361360        if (rc != EOK)
    362361                return rc;
    363362       
    364         switch (addr->version) {
    365         case ip_v4:
     363        switch (addr->family) {
     364        case AF_INET:
    366365                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    367366                    buf[3];
    368367                break;
    369         case ip_v6:
     368        case AF_INET6:
    370369                memcpy(addr->addr6, buf, 16);
    371370                break;
    … …  
    393392        *slash = 0;
    394393       
    395         int rc = inet_addr_version(text, &naddr->version);
     394        int rc = inet_addr_family(text, &naddr->family);
    396395        if (rc != EOK)
    397396                return rc;
    398397       
    399398        uint8_t buf[16];
    400         rc = inet_pton(ipver_af(naddr->version), text, buf);
     399        rc = inet_pton(naddr->family, text, buf);
    401400        *slash = '/';
    402401       
    … …  
    407406        uint8_t prefix;
    408407       
    409         switch (naddr->version) {
    410         case ip_v4:
     408        switch (naddr->family) {
     409        case AF_INET:
    411410                prefix = strtoul(slash, &slash, 10);
    412411                if (prefix > 32)
    … …  
    418417               
    419418                break;
    420         case ip_v6:
     419        case AF_INET6:
    421420                prefix = strtoul(slash, &slash, 10);
    422421                if (prefix > 128)
    … …  
    448447        int rc = 0;
    449448       
    450         switch (addr->version) {
    451         case ip_any:
     449        switch (addr->family) {
     450        case AF_NONE:
    452451                rc = asprintf(bufp, "none");
    453452                break;
    454         case ip_v4:
     453        case AF_INET:
    455454                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    456455                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    457456                    addr->addr & 0xff);
    458457                break;
    459         case ip_v6:
     458        case AF_INET6:
    460459                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    461460                if (*bufp == NULL)
    … …  
    488487        char prefix[INET_PREFIXSTRSIZE];
    489488       
    490         switch (naddr->version) {
    491         case ip_any:
     489        switch (naddr->family) {
     490        case AF_NONE:
    492491                rc = asprintf(bufp, "none");
    493492                break;
    494         case ip_v4:
     493        case AF_INET:
    495494                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    496495                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    498497                    naddr->addr & 0xff, naddr->prefix);
    499498                break;
    500         case ip_v6:
     499        case AF_INET6:
    501500                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    502501                if (*bufp == NULL)
    … …  
    530529}
    531530
    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:
     531uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     532{
     533        switch (addr->family) {
     534        case AF_INET:
    536535                if (v4 != NULL)
    537536                        *v4 = addr->addr;
    538                 break;
    539         case ip_v6:
     537               
     538                break;
     539        case AF_INET6:
    540540                if (v6 != NULL)
    541541                        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,
     542               
     543                break;
     544        }
     545       
     546        return addr->family;
     547}
     548
     549uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    552550    uint8_t *prefix)
    553551{
    554         switch (naddr->version) {
    555         case ip_v4:
     552        switch (naddr->family) {
     553        case AF_INET:
    556554                if (v4 != NULL)
    557555                        *v4 = naddr->addr;
     556               
    558557                if (prefix != NULL)
    559558                        *prefix = naddr->prefix;
    560                 break;
    561         case ip_v6:
     559               
     560                break;
     561        case AF_INET6:
    562562                if (v6 != NULL)
    563563                        memcpy(*v6, naddr->addr6, 16);
     564               
    564565                if (prefix != NULL)
    565566                        *prefix = naddr->prefix;
    566                 break;
    567         default:
    568                 assert(false);
    569                 break;
    570         }
    571 
    572         return naddr->version;
     567               
     568                break;
     569        }
     570       
     571        return naddr->family;
    573572}
    574573
    575574void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    576575{
    577         addr->version = ip_v4;
     576        addr->family = AF_INET;
    578577        addr->addr = v4;
    579578}
    … …  
    581580void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    582581{
    583         naddr->version = ip_v4;
     582        naddr->family = AF_INET;
    584583        naddr->addr = v4;
    585584        naddr->prefix = prefix;
    … …  
    588587void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    589588{
    590         addr->version = ip_v4;
     589        addr->family = AF_INET;
    591590        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    592591}
    … …  
    594593void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    595594{
    596         addr->version = ip_v6;
     595        addr->family = AF_INET6;
    597596        memcpy(addr->addr6, v6, 16);
    598597}
    … …  
    600599void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    601600{
    602         naddr->version = ip_v6;
     601        naddr->family = AF_INET6;
    603602        memcpy(naddr->addr6, v6, 16);
    604603        naddr->prefix = prefix;
    … …  
    608607    inet_addr_t *addr)
    609608{
    610         addr->version = ip_v6;
     609        addr->family = AF_INET6;
    611610        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    612611}
    … …  
    615614    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    616615{
    617         switch (addr->version) {
    618         case ip_v4:
     616        switch (addr->family) {
     617        case AF_INET:
    619618                if (sockaddr_in != NULL) {
    620619                        sockaddr_in->sin_family = AF_INET;
    621620                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    622621                }
    623                 break;
    624         case ip_v6:
     622               
     623                break;
     624        case AF_INET6:
    625625                if (sockaddr_in6 != NULL) {
    626626                        sockaddr_in6->sin6_family = AF_INET6;
    627627                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    628628                }
    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;
     629               
     630                break;
     631        }
     632       
     633        return addr->family;
    677634}
    678635
Note: See TracChangeset for help on using the changeset viewer.