Changeset f023251 in mainline


Ignore:
Timestamp:
2013-09-29T21:06:10Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e948fde
Parents:
13be2583
Message:

HelenOS internet address version should not be based on BSD sockets definition.

Location:
uspace
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/ping/ping.c

    r13be2583 rf023251  
    271271        }
    272272       
    273         uint16_t af = inet_addr_get(&dest_addr, &dest, NULL);
    274         if (af != AF_INET) {
     273        ip_ver_t ver = inet_addr_get(&dest_addr, &dest, NULL);
     274        if (ver != ip_v4) {
    275275                printf("Destination '%s' is not an IPv4 address.\n",
    276276                    argv[optind]);

  • uspace/app/ping6/ping6.c

    r13be2583 rf023251  
    271271        }
    272272       
    273         uint16_t af = inet_addr_get(&dest_addr, NULL, &dest);
    274         if (af != AF_INET6) {
     273        ip_ver_t ver = inet_addr_get(&dest_addr, NULL, &dest);
     274        if (ver != ip_v6) {
    275275                printf("Destination '%s' is not an IPv6 address.\n",
    276276                    argv[optind]);

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

    r13be2583 rf023251  
    3333 */
    3434
     35#include <assert.h>
    3536#include <errno.h>
    3637#include <unistd.h>
    … …  
    5960
    6061static const inet_addr_t inet_addr_any_addr = {
    61         .family = AF_INET,
     62        .version = ip_v4,
    6263        .addr = 0
    6364};
    6465
    6566static const inet_addr_t inet_addr_any_addr6 = {
    66         .family = AF_INET6,
     67        .version = ip_v6,
    6768        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6869};
    … …  
    150151void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    151152{
    152         addr->family = AF_INET;
     153        addr->version = ip_v4;
    153154        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    154155            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    158159    uint8_t prefix)
    159160{
    160         naddr->family = AF_INET;
     161        naddr->version = ip_v4;
    161162        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    162163            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    167168    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    168169{
    169         addr->family = AF_INET6;
     170        addr->version = ip_v6;
    170171        addr->addr6[0] = (a >> 8) & 0xff;
    171172        addr->addr6[1] = a & 0xff;
    … …  
    189190    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    190191{
    191         naddr->family = AF_INET6;
     192        naddr->version = ip_v6;
    192193        naddr->addr6[0] = (a >> 8) & 0xff;
    193194        naddr->addr6[1] = a & 0xff;
    … …  
    209210}
    210211
    211 /** Parse network address family.
    212  *
    213  * @param text Network address in common notation.
    214  * @param af   Place to store network address family.
     212/** Determine address version.
     213 *
     214 * @param text Address in common notation.
     215 * @param af   Place to store address version.
    215216 *
    216217 * @return EOK on success, EINVAL if input is not in valid format.
    217218 *
    218219 */
    219 int inet_addr_family(const char *text, uint16_t *af)
     220static int inet_addr_version(const char *text, ip_ver_t *ver)
    220221{
    221222        char *dot = str_chr(text, '.');
    222223        if (dot != NULL) {
    223                 *af = AF_INET;
     224                *ver = ip_v4;
    224225                return EOK;
    225226        }
    226        
     227
    227228        char *collon = str_chr(text, ':');
    228229        if (collon != NULL) {
    229                 *af = AF_INET6;
     230                *ver = ip_v6;
    230231                return EOK;
    231232        }
    232        
     233
    233234        return EINVAL;
    234235}
    235236
     237static int ipver_af(ip_ver_t ver)
     238{
     239        switch (ver) {
     240        case ip_any:
     241                return AF_NONE;
     242        case ip_v4:
     243                return AF_INET;
     244        case ip_v6:
     245                return AF_INET6;
     246        default:
     247                assert(false);
     248                return EINVAL;
     249        }
     250}
     251
    236252void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    237253{
    238         addr->family = naddr->family;
     254        addr->version = naddr->version;
    239255        memcpy(addr->addr6, naddr->addr6, 16);
    240256}
    … …  
    243259    inet_naddr_t *naddr)
    244260{
    245         naddr->family = addr->family;
     261        naddr->version = addr->version;
    246262        memcpy(naddr->addr6, addr->addr6, 16);
    247263        naddr->prefix = prefix;
    … …  
    250266void inet_addr_any(inet_addr_t *addr)
    251267{
    252         addr->family = AF_NONE;
     268        addr->version = ip_any;
    253269        memset(addr->addr6, 0, 16);
    254270}
    … …  
    256272void inet_naddr_any(inet_naddr_t *naddr)
    257273{
    258         naddr->family = AF_NONE;
     274        naddr->version = ip_any;
    259275        memset(naddr->addr6, 0, 16);
    260276        naddr->prefix = 0;
    … …  
    263279int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    264280{
    265         if (a->family != b->family)
     281        if (a->version != b->version)
    266282                return 0;
    267        
    268         switch (a->family) {
    269         case AF_INET:
     283
     284        switch (a->version) {
     285        case ip_v4:
    270286                return (a->addr == b->addr);
    271         case AF_INET6:
     287        case ip_v6:
    272288                return addr128_compare(a->addr6, b->addr6);
    273289        default:
    … …  
    278294int inet_addr_is_any(const inet_addr_t *addr)
    279295{
    280         return ((addr->family == 0) ||
     296        return ((addr->version == ip_any) ||
    281297            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    282298            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    285301int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    286302{
    287         if (naddr->family != addr->family)
     303        if (naddr->version != addr->version)
    288304                return 0;
    289305       
    290         switch (naddr->family) {
    291         case AF_INET:
     306        switch (naddr->version) {
     307        case ip_v4:
    292308                return (naddr->addr == addr->addr);
    293         case AF_INET6:
     309        case ip_v6:
    294310                return addr128_compare(naddr->addr6, addr->addr6);
    295311        default:
    … …  
    300316int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    301317{
    302         if (naddr->family != addr->family)
     318        if (naddr->version != addr->version)
    303319                return 0;
    304        
    305         switch (naddr->family) {
    306         case AF_INET:
     320
     321        switch (naddr->version) {
     322        case ip_v4:
    307323                if (naddr->prefix > 32)
    308324                        return 0;
    309                
     325
    310326                addr32_t mask =
    311327                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    312328                return ((naddr->addr & mask) == (addr->addr & mask));
    313         case AF_INET6:
     329        case ip_v6:
    314330                if (naddr->prefix > 128)
    315331                        return 0;
    … …  
    352368int inet_addr_parse(const char *text, inet_addr_t *addr)
    353369{
    354         int rc = inet_addr_family(text, &addr->family);
     370        int rc = inet_addr_version(text, &addr->version);
    355371        if (rc != EOK)
    356372                return rc;
    357373       
    358374        uint8_t buf[16];
    359         rc = inet_pton(addr->family, text, buf);
     375        rc = inet_pton(ipver_af(addr->version), text, buf);
    360376        if (rc != EOK)
    361377                return rc;
    362378       
    363         switch (addr->family) {
    364         case AF_INET:
     379        switch (addr->version) {
     380        case ip_v4:
    365381                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    366382                    buf[3];
    367383                break;
    368         case AF_INET6:
     384        case ip_v6:
    369385                memcpy(addr->addr6, buf, 16);
    370386                break;
    … …  
    392408        *slash = 0;
    393409       
    394         int rc = inet_addr_family(text, &naddr->family);
     410        int rc = inet_addr_version(text, &naddr->version);
    395411        if (rc != EOK)
    396412                return rc;
    397413       
    398414        uint8_t buf[16];
    399         rc = inet_pton(naddr->family, text, buf);
     415        rc = inet_pton(ipver_af(naddr->version), text, buf);
    400416        *slash = '/';
    401417       
    … …  
    406422        uint8_t prefix;
    407423       
    408         switch (naddr->family) {
    409         case AF_INET:
     424        switch (naddr->version) {
     425        case ip_v4:
    410426                prefix = strtoul(slash, &slash, 10);
    411427                if (prefix > 32)
    … …  
    417433               
    418434                break;
    419         case AF_INET6:
     435        case ip_v6:
    420436                prefix = strtoul(slash, &slash, 10);
    421437                if (prefix > 128)
    … …  
    447463        int rc = 0;
    448464       
    449         switch (addr->family) {
    450         case AF_NONE:
     465        switch (addr->version) {
     466        case ip_any:
    451467                rc = asprintf(bufp, "none");
    452468                break;
    453         case AF_INET:
     469        case ip_v4:
    454470                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    455471                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    456472                    addr->addr & 0xff);
    457473                break;
    458         case AF_INET6:
     474        case ip_v6:
    459475                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    460476                if (*bufp == NULL)
    … …  
    487503        char prefix[INET_PREFIXSTRSIZE];
    488504       
    489         switch (naddr->family) {
    490         case AF_NONE:
     505        switch (naddr->version) {
     506        case ip_any:
    491507                rc = asprintf(bufp, "none");
    492508                break;
    493         case AF_INET:
     509        case ip_v4:
    494510                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    495511                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    497513                    naddr->addr & 0xff, naddr->prefix);
    498514                break;
    499         case AF_INET6:
     515        case ip_v6:
    500516                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    501517                if (*bufp == NULL)
    … …  
    529545}
    530546
    531 uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
    532 {
    533         switch (addr->family) {
    534         case AF_INET:
     547ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     548{
     549        switch (addr->version) {
     550        case ip_v4:
    535551                if (v4 != NULL)
    536552                        *v4 = addr->addr;
    537                
    538                 break;
    539         case AF_INET6:
     553                break;
     554        case ip_v6:
    540555                if (v6 != NULL)
    541556                        memcpy(*v6, addr->addr6, 16);
    542                
    543                 break;
    544         }
    545        
    546         return addr->family;
    547 }
    548 
    549 uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     557                break;
     558        default:
     559                assert(false);
     560                break;
     561        }
     562
     563        return addr->version;
     564}
     565
     566ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    550567    uint8_t *prefix)
    551568{
    552         switch (naddr->family) {
    553         case AF_INET:
     569        switch (naddr->version) {
     570        case ip_v4:
    554571                if (v4 != NULL)
    555572                        *v4 = naddr->addr;
    556                
    557573                if (prefix != NULL)
    558574                        *prefix = naddr->prefix;
    559                
    560                 break;
    561         case AF_INET6:
     575                break;
     576        case ip_v6:
    562577                if (v6 != NULL)
    563578                        memcpy(*v6, naddr->addr6, 16);
    564                
    565579                if (prefix != NULL)
    566580                        *prefix = naddr->prefix;
    567                
    568                 break;
    569         }
    570        
    571         return naddr->family;
     581                break;
     582        default:
     583                assert(false);
     584                break;
     585        }
     586
     587        return naddr->version;
    572588}
    573589
    574590void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    575591{
    576         addr->family = AF_INET;
     592        addr->version = ip_v4;
    577593        addr->addr = v4;
    578594}
    … …  
    580596void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    581597{
    582         naddr->family = AF_INET;
     598        naddr->version = ip_v4;
    583599        naddr->addr = v4;
    584600        naddr->prefix = prefix;
    … …  
    587603void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    588604{
    589         addr->family = AF_INET;
     605        addr->version = ip_v4;
    590606        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    591607}
    … …  
    593609void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    594610{
    595         addr->family = AF_INET6;
     611        addr->version = ip_v6;
    596612        memcpy(addr->addr6, v6, 16);
    597613}
    … …  
    599615void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    600616{
    601         naddr->family = AF_INET6;
     617        naddr->version = ip_v6;
    602618        memcpy(naddr->addr6, v6, 16);
    603619        naddr->prefix = prefix;
    … …  
    607623    inet_addr_t *addr)
    608624{
    609         addr->family = AF_INET6;
     625        addr->version = ip_v6;
    610626        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    611627}
    … …  
    614630    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    615631{
    616         switch (addr->family) {
    617         case AF_INET:
     632        switch (addr->version) {
     633        case ip_v4:
    618634                if (sockaddr_in != NULL) {
    619635                        sockaddr_in->sin_family = AF_INET;
    620636                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    621637                }
    622                
    623                 break;
    624         case AF_INET6:
     638                break;
     639        case ip_v6:
    625640                if (sockaddr_in6 != NULL) {
    626641                        sockaddr_in6->sin6_family = AF_INET6;
    627642                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    628643                }
    629                
    630                 break;
    631         }
    632        
    633         return addr->family;
     644                break;
     645        default:
     646                assert(false);
     647                break;
     648        }
     649
     650        return ipver_af(addr->version);
    634651}
    635652

  • uspace/lib/c/include/inet/addr.h

    r13be2583 rf023251  
    4444typedef uint8_t addr128_t[16];
    4545
     46typedef enum {
     47        /** Any IP protocol version */
     48        ip_any,
     49        /** IPv4 */
     50        ip_v4,
     51        /** IPv6 */
     52        ip_v6
     53} ip_ver_t;
     54
    4655/** Node address */
    4756typedef struct {
    48         uint16_t family;
     57        /** IP version */
     58        ip_ver_t version;
    4959        union {
    5060                addr32_t addr;
    … …  
    5565/** Network address */
    5666typedef struct {
    57         /** Address family */
    58         uint16_t family;
     67        /** IP version */
     68        ip_ver_t version;
    5969       
    6070        /** Address */
    … …  
    91101    uint16_t, uint16_t, uint16_t, uint16_t, uint8_t);
    92102
    93 extern int inet_addr_family(const char *, uint16_t *);
    94103extern void inet_naddr_addr(const inet_naddr_t *, inet_addr_t *);
    95104extern void inet_addr_naddr(const inet_addr_t *, uint8_t, inet_naddr_t *);
    … …  
    110119extern int inet_naddr_format(const inet_naddr_t *, char **);
    111120
    112 extern uint16_t inet_addr_get(const inet_addr_t *, addr32_t *, addr128_t *);
    113 extern uint16_t inet_naddr_get(const inet_naddr_t *, addr32_t *, addr128_t *,
     121extern ip_ver_t inet_addr_get(const inet_addr_t *, addr32_t *, addr128_t *);
     122extern ip_ver_t inet_naddr_get(const inet_naddr_t *, addr32_t *, addr128_t *,
    114123    uint8_t *);
    115124

  • uspace/srv/net/dhcp/dhcp.c

    r13be2583 rf023251  
    231231        memset(offer, 0, sizeof(*offer));
    232232
    233         yiaddr.family = AF_INET;
    234         yiaddr.addr = uint32_t_be2host(hdr->yiaddr);
     233        inet_addr_set(uint32_t_be2host(hdr->yiaddr), &yiaddr);
    235234        rc = inet_addr_format(&yiaddr, &saddr);
    236235        if (rc != EOK)
    … …  
    240239        free(saddr);
    241240
    242         siaddr.family = AF_INET;
    243         siaddr.addr = uint32_t_be2host(hdr->siaddr);
     241        inet_addr_set(uint32_t_be2host(hdr->siaddr), &siaddr);
    244242        rc = inet_addr_format(&siaddr, &saddr);
    245243        if (rc != EOK)
    … …  
    249247        free(saddr);
    250248
    251         giaddr.family = AF_INET;
    252         giaddr.addr = uint32_t_be2host(hdr->giaddr);
     249        inet_addr_set(uint32_t_be2host(hdr->giaddr), &giaddr);
    253250        rc = inet_addr_format(&giaddr, &saddr);
    254251        if (rc != EOK)
    … …  
    258255        free(saddr);
    259256
    260         offer->oaddr.family = AF_INET;
    261         offer->oaddr.addr = yiaddr.addr;
     257        inet_naddr_set(yiaddr.addr, 0, &offer->oaddr);
    262258
    263259        msgb = (uint8_t *)msg;
    … …  
    299295                        if (opt_len != 4)
    300296                                return EINVAL;
    301                         offer->srv_addr.family = AF_INET;
    302                         offer->srv_addr.addr = dhcp_uint32_decode(&msgb[i]);
     297                        inet_addr_set(dhcp_uint32_decode(&msgb[i]),
     298                            &offer->srv_addr);
    303299                        have_server_id = true;
    304300                        break;
    … …  
    306302                        if (opt_len != 4)
    307303                                return EINVAL;
    308                         offer->router.family = AF_INET;
    309                         offer->router.addr = dhcp_uint32_decode(&msgb[i]);
     304                        inet_addr_set(dhcp_uint32_decode(&msgb[i]),
     305                            &offer->router);
    310306                        break;
    311307                case opt_dns_server:
    312308                        if (opt_len != 4)
    313309                                return EINVAL;
    314                         offer->dns_server.family = AF_INET;
    315                         offer->dns_server.addr = dhcp_uint32_decode(&msgb[i]);
     310                        inet_addr_set(dhcp_uint32_decode(&msgb[i]),
     311                            &offer->dns_server);
    316312                        break;
    317313                case opt_end:
    … …  
    379375
    380376        if (offer->router.addr != 0) {
    381                 defr.family = AF_INET;
    382                 defr.addr = 0;
    383                 defr.prefix = 0;
     377                inet_naddr_set(0, 0, &defr);
    384378
    385379                rc = inetcfg_sroute_create("dhcpdef", &defr, &offer->router, &sroute_id);

  • uspace/srv/net/ethip/arp.c

    r13be2583 rf023251  
    7373       
    7474        addr32_t laddr_v4;
    75         uint16_t laddr_af = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
    76         if (laddr_af != AF_INET)
     75        ip_ver_t laddr_ver = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
     76        if (laddr_ver != ip_v4)
    7777                return;
    7878       

  • uspace/srv/net/ethip/ethip_nic.c

    r13be2583 rf023251  
    354354       
    355355        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    356                 uint16_t af = inet_addr_get(&laddr->addr, NULL, NULL);
    357                 if (af == AF_INET6)
     356                ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, NULL);
     357                if (ver == ip_v6)
    358358                        count++;
    359359        }
    … …  
    373373        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    374374                addr128_t v6;
    375                 uint16_t af = inet_addr_get(&laddr->addr, NULL, &v6);
    376                 if (af != AF_INET6)
     375                ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, &v6);
     376                if (ver != ip_v6)
    377377                        continue;
    378378               

  • uspace/srv/net/inetsrv/addrobj.c

    r13be2583 rf023251  
    218218        inet_addr_t lsrc_addr;
    219219        inet_naddr_addr(&addr->naddr, &lsrc_addr);
    220        
     220
    221221        addr32_t lsrc_v4;
    222222        addr128_t lsrc_v6;
    223         uint16_t lsrc_af = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
    224        
     223        ip_ver_t lsrc_ver = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
     224
    225225        addr32_t ldest_v4;
    226226        addr128_t ldest_v6;
    227         uint16_t ldest_af = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
    228        
    229         if (lsrc_af != ldest_af)
     227        ip_ver_t ldest_ver = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
     228
     229        if (lsrc_ver != ldest_ver)
    230230                return EINVAL;
    231        
     231
    232232        int rc;
    233233        addr48_t ldest_mac;
    234        
    235         switch (ldest_af) {
    236         case AF_INET:
     234
     235        switch (ldest_ver) {
     236        case ip_v4:
    237237                return inet_link_send_dgram(addr->ilink, lsrc_v4, ldest_v4,
    238238                    dgram, proto, ttl, df);
    239         case AF_INET6:
     239        case ip_v6:
    240240                /*
    241241                 * Translate local destination IPv6 address.
    … …  
    244244                if (rc != EOK)
    245245                        return rc;
    246                
     246
    247247                return inet_link_send_dgram6(addr->ilink, ldest_mac, dgram,
    248248                    proto, ttl, df);
    249         }
    250        
     249        default:
     250                assert(false);
     251                break;
     252        }
     253
    251254        return ENOTSUP;
    252255}

  • uspace/srv/net/inetsrv/icmp.c

    r13be2583 rf023251  
    123123{
    124124        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
    125        
     125
    126126        if (dgram->size < sizeof(icmp_echo_t))
    127127                return EINVAL;
    128        
     128
    129129        icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
    130        
     130
    131131        inetping_sdu_t sdu;
    132        
    133         uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
    134         if (family != AF_INET)
     132
     133        ip_ver_t ver = inet_addr_get(&dgram->src, &sdu.src, NULL);
     134        if (ver != ip_v4)
    135135                return EINVAL;
    136        
    137         family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
    138         if (family != AF_INET)
     136
     137        ver = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
     138        if (ver != ip_v4)
    139139                return EINVAL;
    140        
     140
    141141        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    142142        sdu.data = reply + sizeof(icmp_echo_t);
    143143        sdu.size = dgram->size - sizeof(icmp_echo_t);
    144        
     144
    145145        uint16_t ident = uint16_t_be2host(reply->ident);
    146146
    … …  
    154154        if (rdata == NULL)
    155155                return ENOMEM;
    156        
     156
    157157        icmp_echo_t *request = (icmp_echo_t *) rdata;
    158        
     158
    159159        request->type = ICMP_ECHO_REQUEST;
    160160        request->code = 0;
    … …  
    162162        request->ident = host2uint16_t_be(ident);
    163163        request->seq_no = host2uint16_t_be(sdu->seq_no);
    164        
     164
    165165        memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
    166        
     166
    167167        uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
    168168        request->checksum = host2uint16_t_be(checksum);
    169        
     169
    170170        inet_dgram_t dgram;
    171        
     171
    172172        inet_addr_set(sdu->src, &dgram.src);
    173173        inet_addr_set(sdu->dest, &dgram.dest);
    174        
     174
    175175        dgram.iplink = 0;
    176176        dgram.tos = ICMP_TOS;
    177177        dgram.data = rdata;
    178178        dgram.size = rsize;
    179        
     179
    180180        int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
    181        
     181
    182182        free(rdata);
    183183        return rc;

  • uspace/srv/net/inetsrv/icmpv6.c

    r13be2583 rf023251  
    5959       
    6060        addr128_t src_v6;
    61         uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
     61        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
    6262       
    6363        addr128_t dest_v6;
    64         uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
    65        
    66         if ((src_af != dest_af) || (src_af != AF_INET6))
     64        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
     65       
     66        if ((src_ver != dest_ver) || (src_ver != ip_v6))
    6767                return EINVAL;
    6868       
    … …  
    118118        inetping6_sdu_t sdu;
    119119       
    120         uint16_t src_af = inet_addr_get(&dgram->src, NULL, &sdu.src);
    121         uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &sdu.dest);
    122        
    123         if ((src_af != dest_af) || (src_af != AF_INET6))
     120        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &sdu.src);
     121        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &sdu.dest);
     122       
     123        if ((src_ver != dest_ver) || (src_ver != ip_v6))
    124124                return EINVAL;
    125125       

  • uspace/srv/net/inetsrv/inet_link.c

    r13be2583 rf023251  
    294294{
    295295        addr32_t src_v4;
    296         uint16_t src_af = inet_addr_get(&dgram->src, &src_v4, NULL);
    297         if (src_af != AF_INET)
     296        ip_ver_t src_ver = inet_addr_get(&dgram->src, &src_v4, NULL);
     297        if (src_ver != ip_v4)
    298298                return EINVAL;
    299299       
    300300        addr32_t dest_v4;
    301         uint16_t dest_af = inet_addr_get(&dgram->dest, &dest_v4, NULL);
    302         if (dest_af != AF_INET)
     301        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, &dest_v4, NULL);
     302        if (dest_ver != ip_v4)
    303303                return EINVAL;
    304304       
    … …  
    369369{
    370370        addr128_t src_v6;
    371         uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
    372         if (src_af != AF_INET6)
     371        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
     372        if (src_ver != ip_v6)
    373373                return EINVAL;
    374374       
    375375        addr128_t dest_v6;
    376         uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
    377         if (dest_af != AF_INET6)
     376        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
     377        if (dest_ver != ip_v6)
    378378                return EINVAL;
    379379       

  • uspace/srv/net/inetsrv/inetping.c

    r13be2583 rf023251  
    7272                return rc;
    7373       
    74         uint16_t family = inet_addr_get(&local_addr, local, NULL);
    75         if (family != AF_INET)
     74        ip_ver_t ver = inet_addr_get(&local_addr, local, NULL);
     75        if (ver != ip_v4)
    7676                return EINVAL;
    7777       

  • uspace/srv/net/inetsrv/inetping6.c

    r13be2583 rf023251  
    7272                return rc;
    7373       
    74         uint16_t family = inet_addr_get(&local_addr, NULL, local);
    75         if (family != AF_INET6)
     74        ip_ver_t ver = inet_addr_get(&local_addr, NULL, local);
     75        if (ver != ip_v6)
    7676                return EINVAL;
    7777       

  • uspace/srv/net/inetsrv/inetsrv.c

    r13be2583 rf023251  
    6363
    6464static inet_naddr_t solicited_node_mask = {
    65         .family = AF_INET6,
     65        .version = ip_v6,
    6666        .addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, 0xff, 0, 0, 0},
    6767        .prefix = 104
    … …  
    6969
    7070static inet_addr_t broadcast4_all_hosts = {
    71         .family = AF_INET,
     71        .version = ip_v4,
    7272        .addr = 0xffffffff
    7373};
    7474
    7575static inet_addr_t multicast_all_nodes = {
    76         .family = AF_INET6,
     76        .version = ip_v6,
    7777        .addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
    7878};
    … …  
    180180
    181181        if (dgram->iplink != 0) {
     182                /* XXX TODO - IPv6 */
    182183                log_msg(LOG_DEFAULT, LVL_DEBUG, "dgram directly to iplink %zu",
    183184                    dgram->iplink);
    … …  
    187188                        return ENOENT;
    188189
    189                 if (dgram->src.family != AF_INET ||
    190                         dgram->dest.family != AF_INET)
     190                if (dgram->src.version != ip_v4 ||
     191                        dgram->dest.version != ip_v4)
    191192                        return EINVAL;
    192193
    … …  
    225226
    226227        /* Take source address from the address object */
    227         if (remote->family == AF_INET && remote->addr == 0xffffffff) {
    228                 local->family = AF_INET;
     228        if (remote->version == ip_v4 && remote->addr == 0xffffffff) {
     229                /* XXX TODO - IPv6 */
     230                local->version = ip_v4;
    229231                local->addr = 0;
    230232                return EOK;
    231233        }
     234
    232235        inet_naddr_addr(&dir.aobj->naddr, local);
    233236        return EOK;

  • uspace/srv/net/inetsrv/pdu.c

    r13be2583 rf023251  
    533533int ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
    534534{
    535         uint16_t src_af = inet_addr_get(&dgram->src, NULL,
     535        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL,
    536536            &ndp->sender_proto_addr);
    537         if (src_af != AF_INET6)
     537        if (src_ver != ip_v6)
    538538                return EINVAL;
    539539       

  • uspace/srv/net/inetsrv/sroute.c

    r13be2583 rf023251  
    9595inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
    9696{
    97         uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
     97        ip_ver_t addr_ver = inet_addr_get(addr, NULL, NULL);
    9898       
    9999        inet_sroute_t *best = NULL;
    … …  
    104104        list_foreach(sroute_list, sroute_list, inet_sroute_t, sroute) {
    105105                uint8_t dest_bits;
    106                 uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
     106                ip_ver_t dest_ver = inet_naddr_get(&sroute->dest, NULL, NULL,
    107107                    &dest_bits);
    108108               
    109109                /* Skip comparison with different address family */
    110                 if (addr_af != dest_af)
     110                if (addr_ver != dest_ver)
    111111                        continue;
    112112               

  • uspace/srv/net/tcp/pdu.c

    r13be2583 rf023251  
    145145}
    146146
    147 static uint16_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
     147static ip_ver_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
    148148    tcp_phdr6_t *phdr6)
    149149{
    150150        addr32_t src_v4;
    151151        addr128_t src_v6;
    152         uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
    153        
     152        uint16_t src_ver = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     153
    154154        addr32_t dest_v4;
    155155        addr128_t dest_v6;
    156         uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
    157        
    158         assert(src_af == dest_af);
    159        
    160         switch (src_af) {
    161         case AF_INET:
     156        uint16_t dest_ver = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     157
     158        assert(src_ver == dest_ver);
     159
     160        switch (src_ver) {
     161        case ip_v4:
    162162                phdr->src = host2uint32_t_be(src_v4);
    163163                phdr->dest = host2uint32_t_be(dest_v4);
    … …  
    167167                    host2uint16_t_be(pdu->header_size + pdu->text_size);
    168168                break;
    169         case AF_INET6:
     169        case ip_v6:
    170170                host2addr128_t_be(src_v6, phdr6->src);
    171171                host2addr128_t_be(dest_v6, phdr6->dest);
    … …  
    178178                assert(false);
    179179        }
    180        
    181         return src_af;
     180
     181        return src_ver;
    182182}
    183183
    … …  
    266266        tcp_phdr_t phdr;
    267267        tcp_phdr6_t phdr6;
    268        
    269         uint16_t af = tcp_phdr_setup(pdu, &phdr, &phdr6);
    270         switch (af) {
    271         case AF_INET:
     268
     269        ip_ver_t ver = tcp_phdr_setup(pdu, &phdr, &phdr6);
     270        switch (ver) {
     271        case ip_v4:
    272272                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr,
    273273                    sizeof(tcp_phdr_t));
    274274                break;
    275         case AF_INET6:
     275        case ip_v6:
    276276                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr6,
    277277                    sizeof(tcp_phdr6_t));
    … …  
    280280                assert(false);
    281281        }
    282        
     282
    283283        cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size);
    284284        return tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);

  • uspace/srv/net/udp/pdu.c

    r13be2583 rf023251  
    8585}
    8686
    87 static uint16_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
     87static ip_ver_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
    8888    udp_phdr6_t *phdr6)
    8989{
    9090        addr32_t src_v4;
    9191        addr128_t src_v6;
    92         uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
    93        
     92        ip_ver_t src_ver = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     93
    9494        addr32_t dest_v4;
    9595        addr128_t dest_v6;
    96         uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
    97        
    98         assert(src_af == dest_af);
    99        
    100         switch (src_af) {
    101         case AF_INET:
     96        ip_ver_t dest_ver = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     97
     98        assert(src_ver == dest_ver);
     99
     100        switch (src_ver) {
     101        case ip_v4:
    102102                phdr->src_addr = host2uint32_t_be(src_v4);
    103103                phdr->dest_addr = host2uint32_t_be(dest_v4);
    … …  
    106106                phdr->udp_length = host2uint16_t_be(pdu->data_size);
    107107                break;
    108         case AF_INET6:
     108        case ip_v6:
    109109                host2addr128_t_be(src_v6, phdr6->src_addr);
    110110                host2addr128_t_be(dest_v6, phdr6->dest_addr);
    … …  
    116116                assert(false);
    117117        }
    118        
    119         return src_af;
     118
     119        return src_ver;
    120120}
    121121
    … …  
    136136        udp_phdr_t phdr;
    137137        udp_phdr6_t phdr6;
    138        
    139         uint16_t af = udp_phdr_setup(pdu, &phdr, &phdr6);
    140         switch (af) {
    141         case AF_INET:
     138
     139        ip_ver_t ver = udp_phdr_setup(pdu, &phdr, &phdr6);
     140        switch (ver) {
     141        case ip_v4:
    142142                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr,
    143143                    sizeof(udp_phdr_t));
    144144                break;
    145         case AF_INET6:
     145        case ip_v6:
    146146                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr6,
    147147                    sizeof(udp_phdr6_t));
    … …  
    150150                assert(false);
    151151        }
    152        
     152
    153153        return udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
    154154}
Note: See TracChangeset for help on using the changeset viewer.