Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset a2e3ee6 in mainline


Ignore:
Timestamp:
2013-06-20T16:45:58Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
master
Children:
08bb73b
Parents:
19a4f73
Message:

use new network address infrastructure (towards IPv6 support)

Location:
uspace
Files:
2 deleted
61 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/dnscfg/dnscfg.c

    r19a4f73 ra2e3ee6  
    3636
    3737#include <errno.h>
    38 #include <inet/addr2.h>
     38#include <inet/addr.h>
    3939#include <inet/dnsr.h>
    4040#include <ipc/services.h>
     
    7171        char *srv_addr  = argv[0];
    7272       
    73         inet2_addr_t addr;
    74         int rc = inet2_addr_parse(srv_addr, &addr);
     73        inet_addr_t addr;
     74        int rc = inet_addr_parse(srv_addr, &addr);
    7575       
    7676        if (rc != EOK) {
     
    9191static int dnscfg_unset_ns(void)
    9292{
    93         inet2_addr_t addr;
    94         inet2_addr_empty(&addr);
     93        inet_addr_t addr;
     94        inet_addr_any(&addr);
    9595       
    9696        int rc = dnsr_set_srvaddr(&addr);
     
    106106static int dnscfg_print(void)
    107107{
    108         inet2_addr_t addr;
     108        inet_addr_t addr;
    109109        int rc = dnsr_get_srvaddr(&addr);
    110110        if (rc != EOK) {
     
    114114       
    115115        char *addr_str;
    116         rc = inet2_addr_format(&addr, &addr_str);
     116        rc = inet_addr_format(&addr, &addr_str);
    117117        if (rc != EOK) {
    118118                printf("%s: Out of memory.\n", NAME);
  • uspace/app/dnsres/dnsres.c

    r19a4f73 ra2e3ee6  
    3434
    3535#include <errno.h>
    36 #include <inet/addr2.h>
     36#include <inet/addr.h>
    3737#include <inet/dnsr.h>
    3838#include <stdio.h>
     
    6666        }
    6767
    68         rc = inet2_addr_format(&hinfo->addr, &saddr);
     68        rc = inet_addr_format(&hinfo->addr, &saddr);
    6969        if (rc != EOK) {
    7070                dnsr_hostinfo_destroy(hinfo);
  • uspace/app/nettest1/nettest1.c

    r19a4f73 ra2e3ee6  
    360360                }
    361361               
    362                 rc = inet2_addr_sockaddr_in(&hinfo->addr, &address_in);
     362                rc = inet_addr_sockaddr_in(&hinfo->addr, &address_in);
    363363                if (rc != EOK) {
    364364                        printf("Host '%s' not resolved as IPv4 address.\n", argv[argc - 1]);
  • uspace/app/nettest2/nettest2.c

    r19a4f73 ra2e3ee6  
    306306                }
    307307               
    308                 rc = inet2_addr_sockaddr_in(&hinfo->addr, &address_in);
     308                rc = inet_addr_sockaddr_in(&hinfo->addr, &address_in);
    309309                if (rc != EOK) {
    310310                        printf("Host '%s' not resolved as IPv4 address.\n", argv[argc - 1]);
  • uspace/app/nettest3/nettest3.c

    r19a4f73 ra2e3ee6  
    8484                        }
    8585                       
    86                         rc = inet2_addr_sockaddr_in(&hinfo->addr, &addr);
     86                        rc = inet_addr_sockaddr_in(&hinfo->addr, &addr);
    8787                        if (rc != EOK) {
    8888                                printf("Host '%s' not resolved as IPv4 address.\n", argv[1]);
  • uspace/app/nterm/conn.c

    r19a4f73 ra2e3ee6  
    9191                }
    9292               
    93                 rc = inet2_addr_sockaddr_in(&hinfo->addr, &addr);
     93                rc = inet_addr_sockaddr_in(&hinfo->addr, &addr);
    9494                if (rc != EOK) {
    9595                        printf("Host '%s' not resolved as IPv4 address.\n", addr_s);
  • uspace/app/ping/ping.c

    r19a4f73 ra2e3ee6  
    8383static int ping_ev_recv(inetping_sdu_t *sdu)
    8484{
    85         inet2_addr_t src_addr;
    86         inet2_addr_unpack(sdu->src, &src_addr);
    87        
    88         inet2_addr_t dest_addr;
    89         inet2_addr_unpack(sdu->dest, &dest_addr);
     85        inet_addr_t src_addr;
     86        inet_addr_unpack(sdu->src, &src_addr);
     87       
     88        inet_addr_t dest_addr;
     89        inet_addr_unpack(sdu->dest, &dest_addr);
    9090       
    9191        char *asrc;
    92         int rc = inet2_addr_format(&src_addr, &asrc);
     92        int rc = inet_addr_format(&src_addr, &asrc);
    9393        if (rc != EOK)
    9494                return ENOMEM;
    9595       
    9696        char *adest;
    97         rc = inet2_addr_format(&dest_addr, &adest);
     97        rc = inet_addr_format(&dest_addr, &adest);
    9898        if (rc != EOK) {
    9999                free(asrc);
     
    207207
    208208        /* Parse destination address */
    209         inet2_addr_t dest_addr;
    210         rc = inet2_addr_parse(argv[argi], &dest_addr);
     209        inet_addr_t dest_addr;
     210        rc = inet_addr_parse(argv[argi], &dest_addr);
    211211        if (rc != EOK) {
    212212                /* Try interpreting as a host name */
     
    220220        }
    221221       
    222         rc = inet2_addr_pack(&dest_addr, &dest);
     222        rc = inet_addr_pack(&dest_addr, &dest);
    223223        if (rc != EOK) {
    224224                printf(NAME ": Destination '%s' is not an IPv4 address.\n",
     
    234234        }
    235235       
    236         inet2_addr_t src_addr;
    237         inet2_addr_unpack(src, &src_addr);
    238        
    239         rc = inet2_addr_format(&src_addr, &asrc);
     236        inet_addr_t src_addr;
     237        inet_addr_unpack(src, &src_addr);
     238       
     239        rc = inet_addr_format(&src_addr, &asrc);
    240240        if (rc != EOK) {
    241241                printf(NAME ": Out of memory.\n");
     
    243243        }
    244244       
    245         rc = inet2_addr_format(&dest_addr, &adest);
     245        rc = inet_addr_format(&dest_addr, &adest);
    246246        if (rc != EOK) {
    247247                printf(NAME ": Out of memory.\n");
  • uspace/lib/c/Makefile

    r19a4f73 ra2e3ee6  
    9393        generic/futex.c \
    9494        generic/inet/addr.c \
    95         generic/inet/addr2.c \
    9695        generic/inet.c \
    9796        generic/inetcfg.c \
  • uspace/lib/c/generic/dnsr.c

    r19a4f73 ra2e3ee6  
    108108
    109109        info->cname = str_dup(cname_buf);
    110         inet2_addr_unpack(IPC_GET_ARG1(answer), &info->addr);
     110        inet_addr_unpack(IPC_GET_ARG1(answer), &info->addr);
    111111
    112112        *rinfo = info;
     
    123123}
    124124
    125 int dnsr_get_srvaddr(inet2_addr_t *srvaddr)
     125int dnsr_get_srvaddr(inet_addr_t *srvaddr)
    126126{
    127127        async_exch_t *exch = dnsr_exchange_begin();
     
    129129        ipc_call_t answer;
    130130        aid_t req = async_send_0(exch, DNSR_GET_SRVADDR, &answer);
    131         int rc = async_data_read_start(exch, srvaddr, sizeof(inet2_addr_t));
     131        int rc = async_data_read_start(exch, srvaddr, sizeof(inet_addr_t));
    132132       
    133133        loc_exchange_end(exch);
     
    144144}
    145145
    146 int dnsr_set_srvaddr(inet2_addr_t *srvaddr)
     146int dnsr_set_srvaddr(inet_addr_t *srvaddr)
    147147{
    148148        async_exch_t *exch = dnsr_exchange_begin();
     
    150150        ipc_call_t answer;
    151151        aid_t req = async_send_0(exch, DNSR_SET_SRVADDR, &answer);
    152         int rc = async_data_write_start(exch, srvaddr, sizeof(inet2_addr_t));
     152        int rc = async_data_write_start(exch, srvaddr, sizeof(inet_addr_t));
    153153       
    154154        loc_exchange_end(exch);
  • uspace/lib/c/generic/inet.c

    r19a4f73 ra2e3ee6  
    107107int inet_send(inet_dgram_t *dgram, uint8_t ttl, inet_df_t df)
    108108{
    109         async_exch_t *exch = async_exchange_begin(inet_sess);
    110 
     109        uint32_t src;
     110        int rc = inet_addr_pack(&dgram->src, &src);
     111        if (rc != EOK)
     112                return rc;
     113       
     114        uint32_t dest;
     115        rc = inet_addr_pack(&dgram->dest, &dest);
     116        if (rc != EOK)
     117                return EOK;
     118       
     119        async_exch_t *exch = async_exchange_begin(inet_sess);
     120       
    111121        ipc_call_t answer;
    112         aid_t req = async_send_5(exch, INET_SEND, dgram->src.ipv4,
    113             dgram->dest.ipv4, dgram->tos, ttl, df, &answer);
    114         int rc = async_data_write_start(exch, dgram->data, dgram->size);
    115         async_exchange_end(exch);
    116 
     122        aid_t req = async_send_5(exch, INET_SEND, (sysarg_t) src,
     123            (sysarg_t) dest, dgram->tos, ttl, df, &answer);
     124        rc = async_data_write_start(exch, dgram->data, dgram->size);
     125       
     126        async_exchange_end(exch);
     127       
    117128        if (rc != EOK) {
    118129                async_forget(req);
    119130                return rc;
    120131        }
    121 
     132       
    122133        sysarg_t retval;
    123134        async_wait_for(req, &retval);
    124135        if (retval != EOK)
    125136                return retval;
    126 
     137       
    127138        return EOK;
    128139}
     
    130141int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
    131142{
    132         sysarg_t local_addr;
    133         async_exch_t *exch = async_exchange_begin(inet_sess);
    134 
    135         int rc = async_req_2_1(exch, INET_GET_SRCADDR, remote->ipv4,
    136             tos, &local_addr);
    137         async_exchange_end(exch);
    138 
    139         if (rc != EOK)
    140                 return rc;
    141 
    142         local->ipv4 = local_addr;
    143         return EOK;
    144 }
    145 
    146 int inet2_get_srcaddr(inet2_addr_t *remote, uint8_t tos, inet2_addr_t *local)
    147 {
    148143        uint32_t remote_addr;
    149         int rc = inet2_addr_pack(remote, &remote_addr);
     144        int rc = inet_addr_pack(remote, &remote_addr);
    150145        if (rc != EOK)
    151146                return rc;
     
    162157                return rc;
    163158       
    164         inet2_addr_unpack(local_addr, local);
     159        inet_addr_unpack(local_addr, local);
    165160        return EOK;
    166161}
     
    170165        int rc;
    171166        inet_dgram_t dgram;
    172 
    173         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    174         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
     167       
     168        inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
     169        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
    175170        dgram.tos = IPC_GET_ARG3(*call);
    176171
  • uspace/lib/c/generic/inet/addr.c

    r19a4f73 ra2e3ee6  
    3434
    3535#include <errno.h>
     36#include <unistd.h>
     37#include <net/socket_codes.h>
    3638#include <inet/addr.h>
     39#include <net/inet.h>
    3740#include <stdio.h>
    3841
     42static inet_addr_t inet_addr_any_addr = {
     43        .family = AF_INET,
     44        .addr = {0, 0, 0, 0}
     45};
     46
     47static inet_addr_t inet_addr_any_addr6 = {
     48        .family = AF_INET6,
     49        .addr = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
     50};
     51
     52/** Parse network address family.
     53 *
     54 * @param text Network address in common notation.
     55 * @param af   Place to store network address family.
     56 *
     57 * @return EOK on success, EINVAL if input is not in valid format.
     58 *
     59 */
     60int inet_addr_family(const char *text, uint16_t *af)
     61{
     62        char *dot = str_chr(text, '.');
     63        if (dot != NULL) {
     64                *af = AF_INET;
     65                return EOK;
     66        }
     67       
     68        char *collon = str_chr(text, ':');
     69        if (collon != NULL) {
     70                *af = AF_INET6;
     71                return EOK;
     72        }
     73       
     74        *af = AF_NONE;
     75        return EINVAL;
     76}
     77
     78/** Parse node address.
     79 *
     80 * @param text Network address in common notation.
     81 * @param addr Place to store node address.
     82 *
     83 * @return EOK on success, EINVAL if input is not in valid format.
     84 *
     85 */
     86int inet_addr_parse(const char *text, inet_addr_t *addr)
     87{
     88        int rc = inet_addr_family(text, &addr->family);
     89        if (rc != EOK)
     90                return rc;
     91       
     92        rc = inet_pton(addr->family, text, addr->addr);
     93        if (rc != EOK)
     94                return rc;
     95       
     96        return EOK;
     97}
     98
    3999/** Parse network address.
    40100 *
    41  * @param text  Network address in CIDR notation (a.b.c.d/w)
    42  * @param naddr Place to store network address
    43  *
    44  * @return      EOK on success, EINVAL if input is not in valid format
     101 * @param text  Network address in common notation.
     102 * @param naddr Place to store network address.
     103 *
     104 * @return EOK on success, EINVAL if input is not in valid format.
     105 *
    45106 */
    46107int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
    47108{
    48         unsigned long a[4], bits;
    49         char *cp = (char *)text;
    50         int i;
    51 
    52         for (i = 0; i < 3; i++) {
    53                 a[i] = strtoul(cp, &cp, 10);
    54                 if (*cp != '.')
     109        char *slash = str_chr(text, '/');
     110        if (slash == NULL)
     111                return EINVAL;
     112       
     113        *slash = 0;
     114       
     115        int rc = inet_addr_family(text, &naddr->family);
     116        if (rc != EOK)
     117                return rc;
     118       
     119        rc = inet_pton(naddr->family, text, naddr->addr);
     120        *slash = '/';
     121       
     122        if (rc != EOK)
     123                return rc;
     124       
     125        slash++;
     126       
     127        switch (naddr->family) {
     128        case AF_INET:
     129                naddr->prefix = strtoul(slash, &slash, 10);
     130                if (naddr->prefix > 32)
    55131                        return EINVAL;
    56                 ++cp;
    57         }
    58 
    59         a[3] = strtoul(cp, &cp, 10);
    60         if (*cp != '/')
    61                 return EINVAL;
    62         ++cp;
    63 
    64         bits = strtoul(cp, &cp, 10);
    65         if (*cp != '\0')
    66                 return EINVAL;
    67 
    68         naddr->ipv4 = 0;
    69         for (i = 0; i < 4; i++) {
    70                 if (a[i] > 255)
     132                break;
     133        case AF_INET6:
     134                naddr->prefix = strtoul(slash, &slash, 10);
     135                if (naddr->prefix > 128)
    71136                        return EINVAL;
    72                 naddr->ipv4 = (naddr->ipv4 << 8) | a[i];
    73         }
    74 
    75         if (bits > 31)
    76                 return EINVAL;
    77 
    78         naddr->bits = bits;
    79         return EOK;
    80 }
    81 
    82 /** Parse node address.
    83  *
    84  * @param text  Network address in dot notation (a.b.c.d)
    85  * @param addr  Place to store node address
    86  *
    87  * @return      EOK on success, EINVAL if input is not in valid format
    88  */
    89 int inet_addr_parse(const char *text, inet_addr_t *addr)
    90 {
    91         unsigned long a[4];
    92         char *cp = (char *)text;
    93         int i;
    94 
    95         for (i = 0; i < 3; i++) {
    96                 a[i] = strtoul(cp, &cp, 10);
    97                 if (*cp != '.')
    98                         return EINVAL;
    99                 ++cp;
    100         }
    101 
    102         a[3] = strtoul(cp, &cp, 10);
    103         if (*cp != '\0')
    104                 return EINVAL;
    105 
    106         addr->ipv4 = 0;
    107         for (i = 0; i < 4; i++) {
    108                 if (a[i] > 255)
    109                         return EINVAL;
    110                 addr->ipv4 = (addr->ipv4 << 8) | a[i];
    111         }
    112 
    113         return EOK;
    114 }
    115 
    116 /** Format network address.
    117  *
    118  * @param naddr Network address
    119  * @param bufp  Place to store pointer to formatted string (CIDR notation)
    120  *
    121  * @return      EOK on success, ENOMEM if out of memory.
    122  */
    123 int inet_naddr_format(inet_naddr_t *naddr, char **bufp)
     137                break;
     138        default:
     139                return ENOTSUP;
     140        }
     141       
     142        return EOK;
     143}
     144
     145/** Format node address.
     146 *
     147 * @param addr Node address.
     148 * @param bufp Place to store pointer to formatted string.
     149 *
     150 * @return EOK on success.
     151 * @return ENOMEM if out of memory.
     152 * @return ENOTSUP on unsupported address family.
     153 *
     154 */
     155int inet_addr_format(inet_addr_t *addr, char **bufp)
    124156{
    125157        int rc;
    126 
    127         rc = asprintf(bufp, "%d.%d.%d.%d/%d", naddr->ipv4 >> 24,
    128             (naddr->ipv4 >> 16) & 0xff, (naddr->ipv4 >> 8) & 0xff,
    129             naddr->ipv4 & 0xff, naddr->bits);
    130 
     158       
     159        switch (addr->family) {
     160        case AF_NONE:
     161                rc = asprintf(bufp, "none");
     162                break;
     163        case AF_INET:
     164                rc = asprintf(bufp, "%u.%u.%u.%u", addr->addr[0],
     165                    addr->addr[1], addr->addr[2], addr->addr[3]);
     166                break;
     167        case AF_INET6:
     168                // FIXME TODO
     169                break;
     170        default:
     171                return ENOTSUP;
     172        }
     173       
    131174        if (rc < 0)
    132175                return ENOMEM;
    133 
    134         return EOK;
    135 }
    136 
    137 /** Format node address.
    138  *
    139  * @param addr  Node address
    140  * @param bufp  Place to store pointer to formatted string (dot notation)
    141  *
    142  * @return      EOK on success, ENOMEM if out of memory.
    143  */
    144 int inet_addr_format(inet_addr_t *addr, char **bufp)
     176       
     177        return EOK;
     178}
     179
     180/** Format network address.
     181 *
     182 * @param naddr Network address.
     183 * @param bufp  Place to store pointer to formatted string.
     184 *
     185 * @return EOK on success.
     186 * @return ENOMEM if out of memory.
     187 * @return ENOTSUP on unsupported address family.
     188 *
     189 */
     190int inet_naddr_format(inet_naddr_t *naddr, char **bufp)
    145191{
    146192        int rc;
    147 
    148         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    149             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    150             addr->ipv4 & 0xff);
    151 
     193       
     194        switch (naddr->family) {
     195        case AF_NONE:
     196                rc = asprintf(bufp, "none");
     197                break;
     198        case AF_INET:
     199                rc = asprintf(bufp, "%u.%u.%u.%u/%u", naddr->addr[0],
     200                    naddr->addr[1], naddr->addr[2], naddr->addr[3],
     201                    naddr->prefix);
     202                break;
     203        case AF_INET6:
     204                // FIXME TODO
     205                break;
     206        default:
     207                return ENOTSUP;
     208        }
     209       
    152210        if (rc < 0)
    153211                return ENOMEM;
    154 
    155         return EOK;
     212       
     213        return EOK;
     214}
     215
     216/** Create packed IPv4 address
     217 *
     218 * Convert an IPv4 address to a packed 32 bit representation.
     219 *
     220 * @param addr   Source address.
     221 * @param packed Place to store the packed 32 bit representation.
     222 *
     223 * @return EOK on success.
     224 * @return EINVAL if addr is not an IPv4 address.
     225 *
     226 */
     227int inet_addr_pack(inet_addr_t *addr, uint32_t *packed)
     228{
     229        if (addr->family != AF_INET)
     230                return EINVAL;
     231       
     232        *packed = (addr->addr[0] << 24) | (addr->addr[1] << 16) |
     233            (addr->addr[2] << 8) | addr->addr[3];
     234        return EOK;
     235}
     236
     237/** Create packed IPv4 address
     238 *
     239 * Convert an IPv4 address to a packed 32 bit representation.
     240 *
     241 * @param naddr  Source address.
     242 * @param packed Place to store the packed 32 bit representation.
     243 * @param prefix Place to store the number of valid bits.
     244 *
     245 * @return EOK on success.
     246 * @return EINVAL if addr is not an IPv4 address.
     247 *
     248 */
     249int inet_naddr_pack(inet_naddr_t *naddr, uint32_t *packed, uint8_t *prefix)
     250{
     251        if (naddr->family != AF_INET)
     252                return EINVAL;
     253       
     254        *packed = (naddr->addr[0] << 24) | (naddr->addr[1] << 16) |
     255            (naddr->addr[2] << 8) | naddr->addr[3];
     256        *prefix = naddr->prefix;
     257       
     258        return EOK;
     259}
     260
     261void inet_addr_unpack(uint32_t packed, inet_addr_t *addr)
     262{
     263        addr->family = AF_INET;
     264        addr->addr[0] = (packed >> 24) & 0xff;
     265        addr->addr[1] = (packed >> 16) & 0xff;
     266        addr->addr[2] = (packed >> 8) & 0xff;
     267        addr->addr[3] = packed & 0xff;
     268}
     269
     270void inet_naddr_unpack(uint32_t packed, uint8_t prefix, inet_naddr_t *naddr)
     271{
     272        naddr->family = AF_INET;
     273        naddr->addr[0] = (packed >> 24) & 0xff;
     274        naddr->addr[1] = (packed >> 16) & 0xff;
     275        naddr->addr[2] = (packed >> 8) & 0xff;
     276        naddr->addr[3] = packed & 0xff;
     277        naddr->prefix = prefix;
     278}
     279
     280int inet_addr_sockaddr_in(inet_addr_t *addr, sockaddr_in_t *sockaddr_in)
     281{
     282        uint32_t packed;
     283        int rc = inet_addr_pack(addr, &packed);
     284        if (rc != EOK)
     285                return rc;
     286       
     287        sockaddr_in->sin_family = AF_INET;
     288        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(packed);
     289        return EOK;
     290}
     291
     292void inet_naddr_addr(inet_naddr_t *naddr, inet_addr_t *addr)
     293{
     294        addr->family = naddr->family;
     295        memcpy(addr->addr, naddr->addr, INET_ADDR_SIZE);
     296}
     297
     298void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
     299{
     300        addr->family = AF_INET;
     301        addr->addr[0] = a;
     302        addr->addr[1] = b;
     303        addr->addr[2] = c;
     304        addr->addr[3] = d;
     305}
     306
     307void inet_naddr(inet_naddr_t *naddr, uint8_t a, uint8_t b, uint8_t c, uint8_t d,
     308    uint8_t prefix)
     309{
     310        naddr->family = AF_INET;
     311        naddr->addr[0] = a;
     312        naddr->addr[1] = b;
     313        naddr->addr[2] = c;
     314        naddr->addr[3] = d;
     315        naddr->prefix = prefix;
     316}
     317
     318void inet_addr_any(inet_addr_t *addr)
     319{
     320        addr->family = 0;
     321        memset(addr->addr, 0, INET_ADDR_SIZE);
     322}
     323
     324void inet_naddr_any(inet_naddr_t *naddr)
     325{
     326        naddr->family = 0;
     327        memset(naddr->addr, 0, INET_ADDR_SIZE);
     328        naddr->prefix = 0;
     329}
     330
     331int inet_addr_compare(inet_addr_t *a, inet_addr_t *b)
     332{
     333        if (a->family != b->family)
     334                return 0;
     335       
     336        switch (a->family) {
     337        case AF_INET:
     338                return ((a->addr[0] == b->addr[0]) && (a->addr[1] == b->addr[1]) &&
     339                    (a->addr[2] == b->addr[2]) && (a->addr[3] == b->addr[3]));
     340        case AF_INET6:
     341                // FIXME TODO
     342                return 0;
     343        default:
     344                return 0;
     345        }
     346}
     347
     348int inet_addr_is_any(inet_addr_t *addr)
     349{
     350        return ((addr->family == 0) ||
     351            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
     352            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    156353}
    157354
  • uspace/lib/c/generic/inetcfg.c

    r19a4f73 ra2e3ee6  
    136136    sysarg_t link_id, sysarg_t *addr_id)
    137137{
    138         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    139 
    140         ipc_call_t answer;
    141         aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC, naddr->ipv4,
    142             naddr->bits, link_id, &answer);
     138        uint32_t naddr_addr;
     139        uint8_t naddr_bits;
     140        int rc = inet_naddr_pack(naddr, &naddr_addr, &naddr_bits);
     141        if (rc != EOK)
     142                return rc;
     143       
     144        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     145       
     146        ipc_call_t answer;
     147        aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC,
     148            (sysarg_t) naddr_addr, (sysarg_t) naddr_bits, link_id, &answer);
    143149        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    144 
    145         async_exchange_end(exch);
    146 
    147         if (retval != EOK) {
    148                 async_forget(req);
    149                 return retval;
    150         }
    151 
     150       
     151        async_exchange_end(exch);
     152       
     153        if (retval != EOK) {
     154                async_forget(req);
     155                return retval;
     156        }
     157       
    152158        async_wait_for(req, &retval);
    153159        *addr_id = IPC_GET_ARG1(answer);
    154 
     160       
    155161        return retval;
    156162}
     
    196202        assert(act_size <= LOC_NAME_MAXLEN);
    197203        name_buf[act_size] = '\0';
    198 
    199         ainfo->naddr.ipv4 = IPC_GET_ARG1(answer);
    200         ainfo->naddr.bits = IPC_GET_ARG2(answer);
     204       
     205        inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     206            &ainfo->naddr);
    201207        ainfo->ilink = IPC_GET_ARG3(answer);
    202208        ainfo->name = str_dup(name_buf);
     
    284290    inet_addr_t *router, sysarg_t *sroute_id)
    285291{
    286         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    287 
     292        uint32_t dest_addr;
     293        uint8_t dest_bits;
     294        int rc = inet_naddr_pack(dest, &dest_addr, &dest_bits);
     295        if (rc != EOK)
     296                return rc;
     297       
     298        uint32_t router_addr;
     299        rc = inet_addr_pack(router, &router_addr);
     300        if (rc != EOK)
     301                return rc;
     302       
     303        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     304       
    288305        ipc_call_t answer;
    289306        aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
    290             dest->ipv4, dest->bits, router->ipv4, &answer);
     307            (sysarg_t) dest_addr, (sysarg_t) dest_bits, (sysarg_t) router_addr,
     308            &answer);
    291309        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    292 
    293         async_exchange_end(exch);
    294 
    295         if (retval != EOK) {
    296                 async_forget(req);
    297                 return retval;
    298         }
    299 
     310       
     311        async_exchange_end(exch);
     312       
     313        if (retval != EOK) {
     314                async_forget(req);
     315                return retval;
     316        }
     317       
    300318        async_wait_for(req, &retval);
    301319        *sroute_id = IPC_GET_ARG1(answer);
    302 
     320       
    303321        return retval;
    304322}
     
    345363        name_buf[act_size] = '\0';
    346364
    347         srinfo->dest.ipv4 = IPC_GET_ARG1(answer);
    348         srinfo->dest.bits = IPC_GET_ARG2(answer);
    349         srinfo->router.ipv4 = IPC_GET_ARG3(answer);
     365        inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     366            &srinfo->dest);
     367        inet_addr_unpack(IPC_GET_ARG3(answer), &srinfo->router);
    350368        srinfo->name = str_dup(name_buf);
    351369
  • uspace/lib/c/generic/iplink.c

    r19a4f73 ra2e3ee6  
    3939#include <errno.h>
    4040#include <inet/iplink.h>
     41#include <inet/addr.h>
    4142#include <ipc/iplink.h>
    4243#include <ipc/services.h>
     
    8384{
    8485        async_exch_t *exch = async_exchange_begin(iplink->sess);
    85 
     86       
    8687        ipc_call_t answer;
    87         aid_t req = async_send_2(exch, IPLINK_SEND, sdu->lsrc.ipv4,
    88             sdu->ldest.ipv4, &answer);
     88        aid_t req = async_send_2(exch, IPLINK_SEND, (sysarg_t) sdu->lsrc,
     89            (sysarg_t) sdu->ldest, &answer);
    8990        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     91       
    9092        async_exchange_end(exch);
    91 
     93       
    9294        if (rc != EOK) {
    9395                async_forget(req);
    9496                return rc;
    9597        }
    96 
     98       
    9799        sysarg_t retval;
    98100        async_wait_for(req, &retval);
    99101        if (retval != EOK)
    100102                return retval;
    101 
     103       
    102104        return EOK;
    103105}
     
    118120}
    119121
    120 int iplink_addr_add(iplink_t *iplink, iplink_addr_t *addr)
     122int iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
    121123{
     124        uint32_t addr_addr;
     125        int rc = inet_addr_pack(addr, &addr_addr);
     126        if (rc != EOK)
     127                return rc;
     128       
    122129        async_exch_t *exch = async_exchange_begin(iplink->sess);
    123 
    124         int rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t)addr->ipv4);
     130        rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t) addr_addr);
    125131        async_exchange_end(exch);
    126 
     132       
    127133        return rc;
    128134}
    129135
    130 int iplink_addr_remove(iplink_t *iplink, iplink_addr_t *addr)
     136int iplink_addr_remove(iplink_t *iplink, inet_addr_t *addr)
    131137{
     138        uint32_t addr_addr;
     139        int rc = inet_addr_pack(addr, &addr_addr);
     140        if (rc != EOK)
     141                return rc;
     142       
    132143        async_exch_t *exch = async_exchange_begin(iplink->sess);
    133 
    134         int rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t)addr->ipv4);
     144        rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t) addr_addr);
    135145        async_exchange_end(exch);
    136 
     146       
    137147        return rc;
    138148}
     
    141151    ipc_call_t *call)
    142152{
    143         int rc;
    144153        iplink_sdu_t sdu;
    145 
    146         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    147         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
    148 
    149         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     154       
     155        sdu.lsrc = IPC_GET_ARG1(*call);
     156        sdu.ldest = IPC_GET_ARG2(*call);
     157       
     158        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    150159        if (rc != EOK) {
    151160                async_answer_0(callid, rc);
    152161                return;
    153162        }
    154 
     163       
    155164        rc = iplink->ev_ops->recv(iplink, &sdu);
    156165        free(sdu.data);
  • uspace/lib/c/generic/iplink_srv.c

    r19a4f73 ra2e3ee6  
    5454    ipc_call_t *call)
    5555{
    56         int rc;
    57         iplink_srv_addr_t addr;
    58 
    59         addr.ipv4 = IPC_GET_ARG1(*call);
    60 
    61         rc = srv->ops->addr_add(srv, &addr);
     56        int rc = srv->ops->addr_add(srv, IPC_GET_ARG1(*call));
    6257        async_answer_0(callid, rc);
    6358}
     
    6661    ipc_call_t *call)
    6762{
    68         int rc;
    69         iplink_srv_addr_t addr;
    70 
    71         addr.ipv4 = IPC_GET_ARG1(*call);
    72 
    73         rc = srv->ops->addr_remove(srv, &addr);
     63        int rc = srv->ops->addr_remove(srv, IPC_GET_ARG1(*call));
    7464        async_answer_0(callid, rc);
    7565}
     
    8171        int rc;
    8272
    83         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    84         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
     73        sdu.lsrc = IPC_GET_ARG1(*call);
     74        sdu.ldest = IPC_GET_ARG2(*call);
    8575
    8676        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     
    139129                if (!method) {
    140130                        /* The other side has hung up */
    141                         fibril_mutex_lock(&srv->lock);
     131                        fibril_mutex_lock(&srv->lock);
    142132                        srv->connected = false;
    143                         fibril_mutex_unlock(&srv->lock);
     133                        fibril_mutex_unlock(&srv->lock);
    144134                        async_answer_0(callid, EOK);
    145135                        break;
     
    175165
    176166        ipc_call_t answer;
    177         aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
    178             sdu->ldest.ipv4, &answer);
     167        aid_t req = async_send_2(exch, IPLINK_EV_RECV, (sysarg_t) sdu->lsrc,
     168            (sysarg_t) sdu->ldest, &answer);
    179169        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    180170        async_exchange_end(exch);
  • uspace/lib/c/generic/net/inet.c

    r19a4f73 ra2e3ee6  
    3939#include <net/in6.h>
    4040#include <net/inet.h>
    41 
     41#include <inet/addr.h>
    4242#include <errno.h>
    4343#include <mem.h>
  • uspace/lib/c/generic/net/socket_client.c

    r19a4f73 ra2e3ee6  
    8787        /** Parent module service. */
    8888        services_t service;
     89        /** Socket family */
     90        int family;
    8991
    9092        /**
     
    395397        switch (domain) {
    396398        case PF_INET:
     399        case PF_INET6:
    397400                switch (type) {
    398401                case SOCK_STREAM:
     
    433436                break;
    434437
    435         case PF_INET6:
    436438        default:
    437439                return EPFNOSUPPORT;
     
    447449
    448450        memset(socket, 0, sizeof(*socket));
     451        socket->family = domain;
    449452        fibril_rwlock_write_lock(&socket_globals.lock);
    450453
  • uspace/lib/c/generic/net/socket_parse.c

    r19a4f73 ra2e3ee6  
    7979int socket_parse_protocol_family(const char *name, int *pf)
    8080{
     81        if (str_lcmp(name, "PF_INET6", 8) == 0) {
     82                *pf = PF_INET6;
     83                return EOK;
     84        }
     85
    8186        if (str_lcmp(name, "PF_INET", 7) == 0) {
    8287                *pf = PF_INET;
    83                 return EOK;
    84         }
    85        
    86         if (str_lcmp(name, "PF_INET6", 8) == 0) {
    87                 *pf = PF_INET6;
    8888                return EOK;
    8989        }
  • uspace/lib/c/include/inet/addr.h

    r19a4f73 ra2e3ee6  
    3737
    3838#include <stdint.h>
     39#include <net/in.h>
     40
     41#define INET_ADDR_SIZE  16
    3942
    4043/** Node address */
    4144typedef struct {
    42         uint32_t ipv4;
     45        uint16_t family;
     46        uint8_t addr[INET_ADDR_SIZE];
    4347} inet_addr_t;
    4448
    4549/** Network address */
    4650typedef struct {
     51        /** Address family */
     52        uint16_t family;
     53       
    4754        /** Address */
    48         uint32_t ipv4;
    49         /** Number of valid bits in @c ipv4 */
    50         int bits;
     55        uint8_t addr[INET_ADDR_SIZE];
     56       
     57        /** Number of valid bits */
     58        uint8_t prefix;
    5159} inet_naddr_t;
    5260
     61extern int inet_addr_family(const char *, uint16_t *);
     62
     63extern int inet_addr_parse(const char *, inet_addr_t *);
    5364extern int inet_naddr_parse(const char *, inet_naddr_t *);
    54 extern int inet_addr_parse(const char *, inet_addr_t *);
     65
     66extern int inet_addr_format(inet_addr_t *, char **);
    5567extern int inet_naddr_format(inet_naddr_t *, char **);
    56 extern int inet_addr_format(inet_addr_t *, char **);
     68
     69extern int inet_addr_pack(inet_addr_t *, uint32_t *);
     70extern int inet_naddr_pack(inet_naddr_t *, uint32_t *, uint8_t *);
     71
     72extern void inet_addr_unpack(uint32_t, inet_addr_t *);
     73extern void inet_naddr_unpack(uint32_t, uint8_t, inet_naddr_t *);
     74
     75extern int inet_addr_sockaddr_in(inet_addr_t *, sockaddr_in_t *);
     76extern void inet_naddr_addr(inet_naddr_t *, inet_addr_t *);
     77
     78extern void inet_addr(inet_addr_t *, uint8_t, uint8_t, uint8_t, uint8_t);
     79extern void inet_naddr(inet_naddr_t *, uint8_t, uint8_t, uint8_t, uint8_t,
     80    uint8_t);
     81
     82extern void inet_addr_any(inet_addr_t *);
     83extern void inet_naddr_any(inet_naddr_t *);
     84
     85extern int inet_addr_compare(inet_addr_t *, inet_addr_t *);
     86extern int inet_addr_is_any(inet_addr_t *);
    5787
    5888#endif
  • uspace/lib/c/include/inet/dnsr.h

    r19a4f73 ra2e3ee6  
    3737
    3838#include <inet/inet.h>
    39 #include <inet/addr2.h>
     39#include <inet/addr.h>
    4040
    4141enum {
     
    4747        char *cname;
    4848        /** Host address */
    49         inet2_addr_t addr;
     49        inet_addr_t addr;
    5050} dnsr_hostinfo_t;
    5151
     
    5353extern int dnsr_name2host(const char *, dnsr_hostinfo_t **);
    5454extern void dnsr_hostinfo_destroy(dnsr_hostinfo_t *);
    55 extern int dnsr_get_srvaddr(inet2_addr_t *);
    56 extern int dnsr_set_srvaddr(inet2_addr_t *);
     55extern int dnsr_get_srvaddr(inet_addr_t *);
     56extern int dnsr_set_srvaddr(inet_addr_t *);
    5757
    5858#endif
  • uspace/lib/c/include/inet/inet.h

    r19a4f73 ra2e3ee6  
    3737
    3838#include <inet/addr.h>
    39 #include <inet/addr2.h>
    4039#include <sys/types.h>
    4140
     
    6160extern int inet_send(inet_dgram_t *, uint8_t, inet_df_t);
    6261extern int inet_get_srcaddr(inet_addr_t *, uint8_t, inet_addr_t *);
    63 extern int inet2_get_srcaddr(inet2_addr_t *, uint8_t, inet2_addr_t *);
    6462
    6563#endif
  • uspace/lib/c/include/inet/iplink.h

    r19a4f73 ra2e3ee6  
    3838#include <async.h>
    3939#include <sys/types.h>
     40#include <inet/addr.h>
    4041
    4142struct iplink_ev_ops;
     
    4647} iplink_t;
    4748
    48 typedef struct {
    49         uint32_t ipv4;
    50 } iplink_addr_t;
    51 
    52 /** IP link Service Data Unit */
     49/** IPv4 link Service Data Unit */
    5350typedef struct {
    5451        /** Local source address */
    55         iplink_addr_t lsrc;
     52        uint32_t lsrc;
    5653        /** Local destination address */
    57         iplink_addr_t ldest;
     54        uint32_t ldest;
    5855        /** Serialized IP packet */
    5956        void *data;
     
    6158        size_t size;
    6259} iplink_sdu_t;
     60
     61/** IPv6 link Service Data Unit */
     62typedef struct {
     63        /** Target MAC address */
     64        uint64_t hwaddr;
     65        /** Serialized IP packet */
     66        void *data;
     67        /** Size of @c data in bytes */
     68        size_t size;
     69} iplink_sdu6_t;
    6370
    6471typedef struct iplink_ev_ops {
     
    6976extern void iplink_close(iplink_t *);
    7077extern int iplink_send(iplink_t *, iplink_sdu_t *);
    71 extern int iplink_addr_add(iplink_t *, iplink_addr_t *);
    72 extern int iplink_addr_remove(iplink_t *, iplink_addr_t *);
     78extern int iplink_addr_add(iplink_t *, inet_addr_t *);
     79extern int iplink_addr_remove(iplink_t *, inet_addr_t *);
    7380extern int iplink_get_mtu(iplink_t *, size_t *);
    7481
  • uspace/lib/c/include/inet/iplink_srv.h

    r19a4f73 ra2e3ee6  
    5151} iplink_srv_t;
    5252
    53 typedef struct {
    54         uint32_t ipv4;
    55 } iplink_srv_addr_t;
    56 
    5753/** IP link Service Data Unit */
    5854typedef struct {
    5955        /** Local source address */
    60         iplink_srv_addr_t lsrc;
     56        uint32_t lsrc;
    6157        /** Local destination address */
    62         iplink_srv_addr_t ldest;
     58        uint32_t ldest;
    6359        /** Serialized IP packet */
    6460        void *data;
     
    7268        int (*send)(iplink_srv_t *, iplink_srv_sdu_t *);
    7369        int (*get_mtu)(iplink_srv_t *, size_t *);
    74         int (*addr_add)(iplink_srv_t *, iplink_srv_addr_t *);
    75         int (*addr_remove)(iplink_srv_t *, iplink_srv_addr_t *);
     70        int (*addr_add)(iplink_srv_t *, uint32_t);
     71        int (*addr_remove)(iplink_srv_t *, uint32_t);
    7672} iplink_ops_t;
    7773
  • uspace/srv/net/dnsrsrv/dns_type.h

    r19a4f73 ra2e3ee6  
    3939#include <adt/list.h>
    4040#include <inet/inet.h>
    41 #include <inet/addr2.h>
     41#include <inet/addr.h>
    4242#include <stdbool.h>
    4343#include <stdint.h>
     
    116116        char *cname;
    117117        /** Host address */
    118         inet2_addr_t addr;
     118        inet_addr_t addr;
    119119} dns_host_info_t;
    120120
  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    r19a4f73 ra2e3ee6  
    118118       
    119119        uint32_t addr;
    120         rc = inet2_addr_pack(&hinfo->addr, &addr);
     120        rc = inet_addr_pack(&hinfo->addr, &addr);
    121121        if (rc != EOK) {
    122122                async_answer_0(rcallid, rc);
     
    151151        }
    152152       
    153         if (size != sizeof(inet2_addr_t)) {
     153        if (size != sizeof(inet_addr_t)) {
    154154                async_answer_0(callid, EINVAL);
    155155                async_answer_0(iid, EINVAL);
     
    177177        }
    178178       
    179         if (size != sizeof(inet2_addr_t)) {
     179        if (size != sizeof(inet_addr_t)) {
    180180                async_answer_0(callid, EINVAL);
    181181                async_answer_0(iid, EINVAL);
  • uspace/srv/net/dnsrsrv/query.c

    r19a4f73 ra2e3ee6  
    128128
    129129                        info->cname = str_dup(rr->name);
    130                         inet2_addr_unpack(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
     130                        inet_addr_unpack(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
    131131                            &info->addr);
    132132                       
  • uspace/srv/net/dnsrsrv/transport.c

    r19a4f73 ra2e3ee6  
    5757#define REQ_RETRY_MAX 3
    5858
    59 inet2_addr_t dns_server_addr;
     59inet_addr_t dns_server_addr;
    6060
    6161typedef struct {
     
    195195        addr.sin_family = AF_INET;
    196196        addr.sin_port = htons(DNS_SERVER_PORT);
    197         inet2_addr_sockaddr_in(&dns_server_addr, &addr);
     197        inet_addr_sockaddr_in(&dns_server_addr, &addr);
    198198
    199199        rc = dns_message_encode(req, &req_data, &req_size);
  • uspace/srv/net/dnsrsrv/transport.h

    r19a4f73 ra2e3ee6  
    3737#define TRANSPORT_H
    3838
    39 #include <inet/addr2.h>
     39#include <inet/addr.h>
    4040#include "dns_type.h"
    4141
    42 extern inet2_addr_t dns_server_addr;
     42extern inet_addr_t dns_server_addr;
    4343
    4444extern int transport_init(void);
  • uspace/srv/net/ethip/arp.c

    r19a4f73 ra2e3ee6  
    6666
    6767        log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x",
    68             packet.opcode, packet.target_proto_addr.ipv4);
     68            packet.opcode, packet.target_proto_addr);
    6969
    70         laddr = ethip_nic_addr_find(nic, &packet.target_proto_addr);
     70        laddr = ethip_nic_addr_find(nic, packet.target_proto_addr);
    7171        if (laddr != NULL) {
    7272                log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
    7373
    74                 (void) atrans_add(&packet.sender_proto_addr,
     74                (void) atrans_add(packet.sender_proto_addr,
    7575                    &packet.sender_hw_addr);
    7676
     
    8787}
    8888
    89 int arp_translate(ethip_nic_t *nic, iplink_srv_addr_t *src_addr,
    90     iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     89int arp_translate(ethip_nic_t *nic, uint32_t src_addr, uint32_t ip_addr,
     90    mac48_addr_t *mac_addr)
    9191{
    9292        int rc;
     
    9999        packet.opcode = aop_request;
    100100        packet.sender_hw_addr = nic->mac_addr;
    101         packet.sender_proto_addr = *src_addr;
     101        packet.sender_proto_addr = src_addr;
    102102        packet.target_hw_addr.addr = MAC48_BROADCAST;
    103         packet.target_proto_addr = *ip_addr;
     103        packet.target_proto_addr = ip_addr;
    104104
    105105        rc = arp_send_packet(nic, &packet);
  • uspace/srv/net/ethip/arp.h

    r19a4f73 ra2e3ee6  
    4242
    4343extern void arp_received(ethip_nic_t *, eth_frame_t *);
    44 extern int arp_translate(ethip_nic_t *, iplink_srv_addr_t *,
    45     iplink_srv_addr_t *, mac48_addr_t *);
     44extern int arp_translate(ethip_nic_t *, uint32_t, uint32_t, mac48_addr_t *);
    4645
    4746#endif
  • uspace/srv/net/ethip/atrans.c

    r19a4f73 ra2e3ee6  
    4949static FIBRIL_CONDVAR_INITIALIZE(atrans_cv);
    5050
    51 static ethip_atrans_t *atrans_find(iplink_srv_addr_t *ip_addr)
     51static ethip_atrans_t *atrans_find(uint32_t ip_addr)
    5252{
    5353        list_foreach(atrans_list, link) {
     
    5555                    ethip_atrans_t, atrans_list);
    5656
    57                 if (atrans->ip_addr.ipv4 == ip_addr->ipv4)
     57                if (atrans->ip_addr == ip_addr)
    5858                        return atrans;
    5959        }
     
    6262}
    6363
    64 int atrans_add(iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     64int atrans_add(uint32_t ip_addr, mac48_addr_t *mac_addr)
    6565{
    6666        ethip_atrans_t *atrans;
     
    7171                return ENOMEM;
    7272
    73         atrans->ip_addr = *ip_addr;
     73        atrans->ip_addr = ip_addr;
    7474        atrans->mac_addr = *mac_addr;
    7575
     
    8888}
    8989
    90 int atrans_remove(iplink_srv_addr_t *ip_addr)
     90int atrans_remove(uint32_t ip_addr)
    9191{
    9292        ethip_atrans_t *atrans;
     
    106106}
    107107
    108 int atrans_lookup(iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     108int atrans_lookup(uint32_t ip_addr, mac48_addr_t *mac_addr)
    109109{
    110110        ethip_atrans_t *atrans;
  • uspace/srv/net/ethip/atrans.h

    r19a4f73 ra2e3ee6  
    4141#include "ethip.h"
    4242
    43 extern int atrans_add(iplink_srv_addr_t *, mac48_addr_t *);
    44 extern int atrans_remove(iplink_srv_addr_t *);
    45 extern int atrans_lookup(iplink_srv_addr_t *, mac48_addr_t *);
     43extern int atrans_add(uint32_t, mac48_addr_t *);
     44extern int atrans_remove(uint32_t);
     45extern int atrans_lookup(uint32_t, mac48_addr_t *);
    4646extern int atrans_wait_timeout(suseconds_t);
    4747
  • uspace/srv/net/ethip/ethip.c

    r19a4f73 ra2e3ee6  
    5757static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
    5858static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    59 static int ethip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr);
    60 static int ethip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr);
     59static int ethip_addr_add(iplink_srv_t *srv, uint32_t addr);
     60static int ethip_addr_remove(iplink_srv_t *srv, uint32_t addr);
    6161
    6262static void ethip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     
    175175        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
    176176
    177         rc = arp_translate(nic, &sdu->lsrc, &sdu->ldest, &dest_mac_addr);
     177        rc = arp_translate(nic, sdu->lsrc, sdu->ldest, &dest_mac_addr);
    178178        if (rc != EOK) {
    179179                log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IP address 0x%" PRIx32,
    180                     sdu->ldest.ipv4);
     180                    sdu->ldest);
    181181                return rc;
    182182        }
     
    221221        case ETYPE_IP:
    222222                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
    223                 sdu.lsrc.ipv4 = 0;
    224                 sdu.ldest.ipv4 = 0;
     223                sdu.lsrc = 0;
     224                sdu.ldest = 0;
    225225                sdu.data = frame.data;
    226226                sdu.size = frame.size;
     
    244244}
    245245
    246 static int ethip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    247 {
     246static int ethip_addr_add(iplink_srv_t *srv, uint32_t addr)
     247{
     248        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr);
     249       
     250        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     251       
     252        return ethip_nic_addr_add(nic, addr);
     253}
     254
     255static int ethip_addr_remove(iplink_srv_t *srv, uint32_t addr)
     256{
     257        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr);
     258       
    248259        ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
    249 
    250         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr->ipv4);
    251         return ethip_nic_addr_add(nic, addr);
    252 }
    253 
    254 static int ethip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    255 {
    256         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
    257 
    258         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr->ipv4);
     260       
    259261        return ethip_nic_addr_add(nic, addr);
    260262}
  • uspace/srv/net/ethip/ethip.h

    r19a4f73 ra2e3ee6  
    4848typedef struct {
    4949        link_t addr_list;
    50         iplink_srv_addr_t addr;
     50        uint32_t addr;
    5151} ethip_link_addr_t;
    5252
     
    104104        mac48_addr_t sender_hw_addr;
    105105        /** Sender protocol address */
    106         iplink_srv_addr_t sender_proto_addr;
     106        uint32_t sender_proto_addr;
    107107        /** Target hardware address */
    108108        mac48_addr_t target_hw_addr;
    109109        /** Target protocol address */
    110         iplink_srv_addr_t target_proto_addr;
     110        uint32_t target_proto_addr;
    111111} arp_eth_packet_t;
    112112
     
    114114typedef struct {
    115115        link_t atrans_list;
    116         iplink_srv_addr_t ip_addr;
     116        uint32_t ip_addr;
    117117        mac48_addr_t mac_addr;
    118118} ethip_atrans_t;
  • uspace/srv/net/ethip/ethip_nic.c

    r19a4f73 ra2e3ee6  
    121121}
    122122
    123 static ethip_link_addr_t *ethip_nic_addr_new(iplink_srv_addr_t *addr)
     123static ethip_link_addr_t *ethip_nic_addr_new(uint32_t addr)
    124124{
    125125        ethip_link_addr_t *laddr = calloc(1, sizeof(ethip_link_addr_t));
    126 
    127126        if (laddr == NULL) {
    128127                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC address structure. "
     
    130129                return NULL;
    131130        }
    132 
     131       
    133132        link_initialize(&laddr->addr_list);
    134         laddr->addr.ipv4 = addr->ipv4;
     133        laddr->addr = addr;
     134       
    135135        return laddr;
    136136}
     
    335335}
    336336
    337 int ethip_nic_addr_add(ethip_nic_t *nic, iplink_srv_addr_t *addr)
    338 {
    339         ethip_link_addr_t *laddr;
    340 
     337int ethip_nic_addr_add(ethip_nic_t *nic, uint32_t addr)
     338{
    341339        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
    342         laddr = ethip_nic_addr_new(addr);
     340       
     341        ethip_link_addr_t *laddr = ethip_nic_addr_new(addr);
    343342        if (laddr == NULL)
    344343                return ENOMEM;
    345 
     344       
    346345        list_append(&laddr->addr_list, &nic->addr_list);
    347346        return EOK;
    348347}
    349348
    350 int ethip_nic_addr_remove(ethip_nic_t *nic, iplink_srv_addr_t *addr)
    351 {
    352         ethip_link_addr_t *laddr;
    353 
     349int ethip_nic_addr_remove(ethip_nic_t *nic, uint32_t addr)
     350{
    354351        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");
    355 
    356         laddr = ethip_nic_addr_find(nic, addr);
     352       
     353        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, addr);
    357354        if (laddr == NULL)
    358355                return ENOENT;
    359 
     356       
    360357        list_remove(&laddr->addr_list);
    361358        ethip_link_addr_delete(laddr);
     
    364361
    365362ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *nic,
    366     iplink_srv_addr_t *addr)
     363    uint32_t addr)
    367364{
    368365        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
     
    372369                    ethip_link_addr_t, addr_list);
    373370
    374                 if (addr->ipv4 == laddr->addr.ipv4)
     371                if (addr == laddr->addr)
    375372                        return laddr;
    376373        }
  • uspace/srv/net/ethip/ethip_nic.h

    r19a4f73 ra2e3ee6  
    4444extern ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t);
    4545extern int ethip_nic_send(ethip_nic_t *, void *, size_t);
    46 extern int ethip_nic_addr_add(ethip_nic_t *, iplink_srv_addr_t *);
    47 extern int ethip_nic_addr_remove(ethip_nic_t *, iplink_srv_addr_t *);
    48 extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *,
    49     iplink_srv_addr_t *);
     46extern int ethip_nic_addr_add(ethip_nic_t *, uint32_t);
     47extern int ethip_nic_addr_remove(ethip_nic_t *, uint32_t);
     48extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *, uint32_t);
    5049
    5150#endif
  • uspace/srv/net/ethip/pdu.c

    r19a4f73 ra2e3ee6  
    170170        mac48_encode(&packet->sender_hw_addr, pfmt->sender_hw_addr);
    171171        pfmt->sender_proto_addr =
    172             host2uint32_t_be(packet->sender_proto_addr.ipv4);
     172            host2uint32_t_be(packet->sender_proto_addr);
    173173        mac48_encode(&packet->target_hw_addr, pfmt->target_hw_addr);
    174174        pfmt->target_proto_addr =
    175             host2uint32_t_be(packet->target_proto_addr.ipv4);
     175            host2uint32_t_be(packet->target_proto_addr);
    176176
    177177        *rdata = data;
     
    228228
    229229        mac48_decode(pfmt->sender_hw_addr, &packet->sender_hw_addr);
    230         packet->sender_proto_addr.ipv4 =
     230        packet->sender_proto_addr =
    231231            uint32_t_be2host(pfmt->sender_proto_addr);
    232232        mac48_decode(pfmt->target_hw_addr, &packet->target_hw_addr);
    233         packet->target_proto_addr.ipv4 =
     233        packet->target_proto_addr =
    234234            uint32_t_be2host(pfmt->target_proto_addr);
    235235        log_msg(LOG_DEFAULT, LVL_DEBUG, "packet->tpa = %x\n", pfmt->target_proto_addr);
     
    238238}
    239239
    240 
    241240/** @}
    242241 */
  • uspace/srv/net/inetsrv/addrobj.c

    r19a4f73 ra2e3ee6  
    112112inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
    113113{
    114         uint32_t mask;
    115 
    116         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find(%x)", (unsigned)addr->ipv4);
    117 
    118         fibril_mutex_lock(&addr_list_lock);
    119 
     114        uint32_t addr_addr;
     115        int rc = inet_addr_pack(addr, &addr_addr);
     116        if (rc != EOK)
     117                return NULL;
     118       
     119        fibril_mutex_lock(&addr_list_lock);
     120       
    120121        list_foreach(addr_list, link) {
    121122                inet_addrobj_t *naddr = list_get_instance(link,
    122123                    inet_addrobj_t, addr_list);
    123 
    124                 mask = inet_netmask(naddr->naddr.bits);
    125                 if ((naddr->naddr.ipv4 & mask) == (addr->ipv4 & mask)) {
     124               
     125                uint32_t naddr_addr;
     126                uint8_t naddr_bits;
     127                rc = inet_naddr_pack(&naddr->naddr, &naddr_addr, &naddr_bits);
     128                if (rc != EOK)
     129                        continue;
     130               
     131                uint32_t mask = inet_netmask(naddr_bits);
     132                if ((naddr_addr & mask) == (addr_addr & mask)) {
    126133                        fibril_mutex_unlock(&addr_list_lock);
    127134                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
     
    218225{
    219226        inet_addr_t lsrc_addr;
    220         inet_addr_t *ldest_addr;
    221 
    222         lsrc_addr.ipv4 = addr->naddr.ipv4;
    223         ldest_addr = ldest;
    224 
     227        inet_naddr_addr(&addr->naddr, &lsrc_addr);
     228       
     229        inet_addr_t *ldest_addr = ldest;
     230       
    225231        return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest_addr, dgram,
    226232            proto, ttl, df);
  • uspace/srv/net/inetsrv/icmp.c

    r19a4f73 ra2e3ee6  
    120120static int icmp_recv_echo_reply(inet_dgram_t *dgram)
    121121{
    122         icmp_echo_t *reply;
    123         inetping_sdu_t sdu;
    124         uint16_t ident;
    125 
    126122        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
    127 
     123       
    128124        if (dgram->size < sizeof(icmp_echo_t))
    129125                return EINVAL;
    130 
    131         reply = (icmp_echo_t *)dgram->data;
    132 
    133         sdu.src = dgram->src;
    134         sdu.dest = dgram->dest;
     126       
     127        icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
     128       
     129        inetping_sdu_t sdu;
     130       
     131        int rc = inet_addr_pack(&dgram->src, &sdu.src);
     132        if (rc != EOK)
     133                return rc;
     134       
     135        rc = inet_addr_pack(&dgram->dest, &sdu.dest);
     136        if (rc != EOK)
     137                return rc;
     138       
    135139        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    136140        sdu.data = reply + sizeof(icmp_echo_t);
    137141        sdu.size = dgram->size - sizeof(icmp_echo_t);
    138         ident = uint16_t_be2host(reply->ident);
     142       
     143        uint16_t ident = uint16_t_be2host(reply->ident);
    139144
    140145        return inetping_recv(ident, &sdu);
     
    143148int icmp_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    144149{
    145         inet_dgram_t dgram;
    146         icmp_echo_t *request;
    147         void *rdata;
    148         size_t rsize;
    149         uint16_t checksum;
    150         int rc;
    151 
    152         rsize = sizeof(icmp_echo_t) + sdu->size;
    153         rdata = calloc(rsize, 1);
     150        size_t rsize = sizeof(icmp_echo_t) + sdu->size;
     151        void *rdata = calloc(rsize, 1);
    154152        if (rdata == NULL)
    155153                return ENOMEM;
    156 
    157         request = (icmp_echo_t *)rdata;
    158 
     154       
     155        icmp_echo_t *request = (icmp_echo_t *)rdata;
     156       
    159157        request->type = ICMP_ECHO_REQUEST;
    160158        request->code = 0;
     
    162160        request->ident = host2uint16_t_be(ident);
    163161        request->seq_no = host2uint16_t_be(sdu->seq_no);
    164 
     162       
    165163        memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
    166 
    167         checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
     164       
     165        uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
    168166        request->checksum = host2uint16_t_be(checksum);
    169 
    170         dgram.src = sdu->src;
    171         dgram.dest = sdu->dest;
     167       
     168        inet_dgram_t dgram;
     169       
     170        inet_addr_unpack(sdu->src, &dgram.src);
     171        inet_addr_unpack(sdu->dest, &dgram.dest);
     172       
    172173        dgram.tos = ICMP_TOS;
    173174        dgram.data = rdata;
    174175        dgram.size = rsize;
    175 
    176         rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
    177 
     176       
     177        int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
     178       
    178179        free(rdata);
    179180        return rc;
  • uspace/srv/net/inetsrv/inet_link.c

    r19a4f73 ra2e3ee6  
    153153{
    154154        inet_link_t *ilink;
    155         iplink_addr_t iaddr;
     155        inet_addr_t iaddr;
    156156        int rc;
    157157
     
    196196
    197197        static int first = 1;
    198         /* XXX For testing: set static IP address 10.0.2.15/24 */
     198       
    199199        addr = inet_addrobj_new();
     200       
    200201        if (first) {
    201                 addr->naddr.ipv4 = (127 << 24) + (0 << 16) + (0 << 8) + 1;
     202                inet_naddr(&addr->naddr, 127, 0, 0, 1, 24);
    202203                first = 0;
    203204        } else {
    204                 addr->naddr.ipv4 = (10 << 24) + (0 << 16) + (2 << 8) + 15;
    205         }
    206         addr->naddr.bits = 24;
     205                /* XXX For testing: set static IP address 10.0.2.15/24 */
     206                inet_naddr(&addr->naddr, 10, 0, 2, 15, 24);
     207        }
     208       
    207209        addr->ilink = ilink;
    208210        addr->name = str_dup("v4a");
     
    215217        }
    216218
    217         iaddr.ipv4 = addr->naddr.ipv4;
     219        inet_naddr_addr(&addr->naddr, &iaddr);
    218220        rc = iplink_addr_add(ilink->iplink, &iaddr);
    219221        if (rc != EOK) {
     
    257259    inet_addr_t *ldest, inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
    258260{
    259         iplink_sdu_t sdu;
    260         inet_packet_t packet;
    261         int rc;
    262         size_t offs, roffs;
    263 
    264261        /*
    265262         * Fill packet structure. Fragmentation is performed by
    266263         * inet_pdu_encode().
    267264         */
     265        inet_packet_t packet;
     266       
    268267        packet.src = dgram->src;
    269268        packet.dest = dgram->dest;
     
    274273        packet.data = dgram->data;
    275274        packet.size = dgram->size;
    276 
    277         sdu.lsrc.ipv4 = lsrc->ipv4;
    278         sdu.ldest.ipv4 = ldest->ipv4;
    279 
    280         offs = 0;
     275       
     276        iplink_sdu_t sdu;
     277       
     278        int rc = inet_addr_pack(lsrc, &sdu.lsrc);
     279        if (rc != EOK)
     280                return rc;
     281       
     282        rc = inet_addr_pack(ldest, &sdu.ldest);
     283        if (rc != EOK)
     284                return rc;
     285       
     286        size_t offs = 0;
    281287        do {
     288                size_t roffs;
     289               
    282290                /* Encode one fragment */
    283291                rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
     
    285293                if (rc != EOK)
    286294                        return rc;
    287 
     295               
    288296                /* Send the PDU */
    289297                rc = iplink_send(ilink->iplink, &sdu);
    290298                free(sdu.data);
    291 
     299               
    292300                offs = roffs;
    293301        } while (offs < packet.size);
    294 
     302       
    295303        return rc;
    296304}
  • uspace/srv/net/inetsrv/inetcfg.c

    r19a4f73 ra2e3ee6  
    5656        inet_link_t *ilink;
    5757        inet_addrobj_t *addr;
    58         iplink_addr_t iaddr;
     58        inet_addr_t iaddr;
    5959        int rc;
    6060
     
    8282        }
    8383
    84         iaddr.ipv4 = addr->naddr.ipv4;
     84        inet_naddr_addr(&addr->naddr, &iaddr);
    8585        rc = iplink_addr_add(ilink->iplink, &iaddr);
    8686        if (rc != EOK) {
     
    254254        }
    255255
    256         naddr.ipv4 = IPC_GET_ARG1(*call);
    257         naddr.bits = IPC_GET_ARG2(*call);
    258         link_id    = IPC_GET_ARG3(*call);
     256        inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &naddr);
     257        link_id = IPC_GET_ARG3(*call);
    259258
    260259        addr_id = 0;
     
    279278static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
    280279{
     280        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
     281       
     282        sysarg_t addr_id = IPC_GET_ARG1(*call);
     283       
     284        inet_addr_info_t ainfo;
     285       
     286        inet_naddr_any(&ainfo.naddr);
     287        ainfo.ilink = 0;
     288        ainfo.name = NULL;
     289       
    281290        ipc_callid_t rcallid;
    282291        size_t max_size;
    283 
    284         sysarg_t addr_id;
    285         inet_addr_info_t ainfo;
    286         int rc;
    287 
    288         addr_id = IPC_GET_ARG1(*call);
    289         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    290 
    291         ainfo.naddr.ipv4 = 0;
    292         ainfo.naddr.bits = 0;
    293         ainfo.ilink = 0;
    294         ainfo.name = NULL;
    295 
     292       
    296293        if (!async_data_read_receive(&rcallid, &max_size)) {
    297294                async_answer_0(rcallid, EREFUSED);
     
    299296                return;
    300297        }
    301 
    302         rc = inetcfg_addr_get(addr_id, &ainfo);
    303         if (rc != EOK) {
    304                 async_answer_0(callid, rc);
    305                 return;
    306         }
    307 
     298       
     299        int rc = inetcfg_addr_get(addr_id, &ainfo);
     300        if (rc != EOK) {
     301                async_answer_0(callid, rc);
     302                return;
     303        }
     304       
     305        uint32_t naddr_addr;
     306        uint8_t naddr_bits;
     307        rc = inet_naddr_pack(&ainfo.naddr, &naddr_addr, &naddr_bits);
     308        if (rc != EOK) {
     309                async_answer_0(callid, rc);
     310                return;
     311        }
     312       
    308313        sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
    309314            min(max_size, str_size(ainfo.name)));
    310315        free(ainfo.name);
    311 
    312         async_answer_3(callid, retval, ainfo.naddr.ipv4, ainfo.naddr.bits,
    313             ainfo.ilink);
     316       
     317        async_answer_3(callid, retval, (sysarg_t) naddr_addr,
     318            (sysarg_t) naddr_bits, ainfo.ilink);
    314319}
    315320
     
    476481    ipc_call_t *call)
    477482{
     483        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
     484       
    478485        char *name;
     486        int rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
     487            0, NULL);
     488        if (rc != EOK) {
     489                async_answer_0(callid, rc);
     490                return;
     491        }
     492       
    479493        inet_naddr_t dest;
    480494        inet_addr_t router;
    481         sysarg_t sroute_id;
    482         int rc;
    483 
    484         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
    485 
    486         rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    487             0, NULL);
    488         if (rc != EOK) {
    489                 async_answer_0(callid, rc);
    490                 return;
    491         }
    492 
    493         dest.ipv4   = IPC_GET_ARG1(*call);
    494         dest.bits   = IPC_GET_ARG2(*call);
    495         router.ipv4 = IPC_GET_ARG3(*call);
    496 
    497         sroute_id = 0;
     495       
     496        inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &dest);
     497        inet_addr_unpack(IPC_GET_ARG3(*call), &router);
     498       
     499        sysarg_t sroute_id = 0;
    498500        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    499501        free(name);
     
    516518static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
    517519{
     520        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
     521       
     522        sysarg_t sroute_id = IPC_GET_ARG1(*call);
     523       
     524        inet_sroute_info_t srinfo;
     525       
     526        inet_naddr_any(&srinfo.dest);
     527        inet_addr_any(&srinfo.router);
     528        srinfo.name = NULL;
     529       
    518530        ipc_callid_t rcallid;
    519531        size_t max_size;
    520 
    521         sysarg_t sroute_id;
    522         inet_sroute_info_t srinfo;
    523         int rc;
    524 
    525         sroute_id = IPC_GET_ARG1(*call);
    526         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    527 
    528         srinfo.dest.ipv4 = 0;
    529         srinfo.dest.bits = 0;
    530         srinfo.router.ipv4 = 0;
    531         srinfo.name = NULL;
    532 
    533532        if (!async_data_read_receive(&rcallid, &max_size)) {
    534533                async_answer_0(rcallid, EREFUSED);
     
    536535                return;
    537536        }
    538 
    539         rc = inetcfg_sroute_get(sroute_id, &srinfo);
    540         if (rc != EOK) {
    541                 async_answer_0(callid, rc);
    542                 return;
    543         }
    544 
     537       
     538        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
     539        if (rc != EOK) {
     540                async_answer_0(callid, rc);
     541                return;
     542        }
     543       
     544        uint32_t dest_addr;
     545        uint8_t dest_bits;
     546        rc = inet_naddr_pack(&srinfo.dest, &dest_addr, &dest_bits);
     547        if (rc != EOK) {
     548                async_answer_0(callid, rc);
     549                return;
     550        }
     551       
     552        uint32_t router_addr;
     553        rc = inet_addr_pack(&srinfo.router, &router_addr);
     554        if (rc != EOK) {
     555                async_answer_0(callid, rc);
     556                return;
     557        }
     558       
    545559        sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
    546560            min(max_size, str_size(srinfo.name)));
    547561        free(srinfo.name);
    548 
    549         async_answer_3(callid, retval, srinfo.dest.ipv4, srinfo.dest.bits,
    550             srinfo.router.ipv4);
     562       
     563        async_answer_3(callid, retval, (sysarg_t) dest_addr,
     564            (sysarg_t) dest_bits, (sysarg_t) router_addr);
    551565}
    552566
  • uspace/srv/net/inetsrv/inetping.c

    r19a4f73 ra2e3ee6  
    6262}
    6363
    64 static int inetping_get_srcaddr(inetping_client_t *client, inet_addr_t *remote,
    65     inet_addr_t *local)
    66 {
    67         return inet_get_srcaddr(remote, ICMP_TOS, local);
     64static int inetping_get_srcaddr(inetping_client_t *client, uint32_t remote,
     65    uint32_t *local)
     66{
     67        inet_addr_t remote_addr;
     68        inet_addr_unpack(remote, &remote_addr);
     69       
     70        inet_addr_t local_addr;
     71        int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
     72        if (rc != EOK)
     73                return rc;
     74       
     75        return inet_addr_pack(&local_addr, local);
    6876}
    6977
     
    8290        exch = async_exchange_begin(client->sess);
    8391
    84         aid_t req = async_send_3(exch, INETPING_EV_RECV, sdu->src.ipv4,
    85             sdu->dest.ipv4, sdu->seq_no, &answer);
     92        aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
     93            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    8694        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    8795        async_exchange_end(exch);
     
    116124        }
    117125
    118         sdu.src.ipv4 = IPC_GET_ARG1(*call);
    119         sdu.dest.ipv4 = IPC_GET_ARG2(*call);
     126        sdu.src = IPC_GET_ARG1(*call);
     127        sdu.dest = IPC_GET_ARG2(*call);
    120128        sdu.seq_no = IPC_GET_ARG3(*call);
    121129
     
    129137    ipc_callid_t callid, ipc_call_t *call)
    130138{
    131         inet_addr_t remote;
    132         inet_addr_t local;
    133         int rc;
    134 
    135139        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    136 
    137         remote.ipv4 = IPC_GET_ARG1(*call);
    138         local.ipv4 = 0;
    139 
    140         rc = inetping_get_srcaddr(client, &remote, &local);
    141         async_answer_1(callid, rc, local.ipv4);
     140       
     141        uint32_t remote = IPC_GET_ARG1(*call);
     142        uint32_t local = 0;
     143       
     144        int rc = inetping_get_srcaddr(client, remote, &local);
     145        async_answer_1(callid, rc, (sysarg_t) local);
    142146}
    143147
  • uspace/srv/net/inetsrv/inetping.h

    r19a4f73 ra2e3ee6  
    3838#define INETPING_H_
    3939
     40#include "inetsrv.h"
     41
    4042extern void inetping_conn(ipc_callid_t, ipc_call_t *, void *);
    4143extern int inetping_recv(uint16_t, inetping_sdu_t *);
  • uspace/srv/net/inetsrv/inetsrv.c

    r19a4f73 ra2e3ee6  
    104104        }
    105105
    106         sroute->dest.ipv4 = 0;
    107         sroute->dest.bits = 0;
    108         sroute->router.ipv4 = (10 << 24) | (0 << 16) | (2 << 8) | 2;
     106        inet_naddr(&sroute->dest, 0, 0, 0, 0, 0);
     107        inet_addr(&sroute->router, 10, 0, 2, 2);
    109108        sroute->name = str_dup("default");
    110109        inet_sroute_add(sroute);
    111110
    112         rc = inet_link_discovery_start();
     111        rc = inet_link_discovery_start();
    113112        if (rc != EOK)
    114113                return EEXIST;
     
    194193
    195194        /* Take source address from the address object */
    196         local->ipv4 = dir.aobj->naddr.ipv4;
     195        inet_naddr_addr(&dir.aobj->naddr, local);
    197196        return EOK;
    198197}
     
    201200    ipc_call_t *call)
    202201{
     202        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
     203       
    203204        inet_addr_t remote;
    204         uint8_t tos;
     205        inet_addr_unpack(IPC_GET_ARG1(*call), &remote);
     206        uint8_t tos = IPC_GET_ARG2(*call);
     207       
    205208        inet_addr_t local;
    206         int rc;
    207 
    208         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
    209 
    210         remote.ipv4 = IPC_GET_ARG1(*call);
    211         tos = IPC_GET_ARG2(*call);
    212         local.ipv4 = 0;
    213 
    214         rc = inet_get_srcaddr(&remote, tos, &local);
    215         async_answer_1(callid, rc, local.ipv4);
     209        int rc = inet_get_srcaddr(&remote, tos, &local);
     210        if (rc != EOK) {
     211                async_answer_0(callid, rc);
     212                return;
     213        }
     214       
     215        uint32_t local_addr;
     216        rc = inet_addr_pack(&local, &local_addr);
     217        if (rc != EOK) {
     218                async_answer_0(callid, rc);
     219                return;
     220        }
     221       
     222        async_answer_1(callid, rc, (sysarg_t) local_addr);
    216223}
    217224
     
    219226    ipc_call_t *call)
    220227{
     228        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
     229       
    221230        inet_dgram_t dgram;
    222         uint8_t ttl;
    223         int df;
    224         int rc;
    225 
    226         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
    227 
    228         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    229         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
     231       
     232        inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
     233        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
    230234        dgram.tos = IPC_GET_ARG3(*call);
    231         ttl = IPC_GET_ARG4(*call);
    232         df = IPC_GET_ARG5(*call);
    233 
    234         rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
     235       
     236        uint8_t ttl = IPC_GET_ARG4(*call);
     237        int df = IPC_GET_ARG5(*call);
     238       
     239        int rc = async_data_write_accept(&dgram.data, false, 0, 0, 0,
     240            &dgram.size);
    235241        if (rc != EOK) {
    236242                async_answer_0(callid, rc);
    237243                return;
    238244        }
    239 
     245       
    240246        rc = inet_send(client, &dgram, client->protocol, ttl, df);
    241 
     247       
    242248        free(dgram.data);
    243249        async_answer_0(callid, rc);
     
    365371int inet_ev_recv(inet_client_t *client, inet_dgram_t *dgram)
    366372{
     373        uint32_t src;
     374        int rc = inet_addr_pack(&dgram->src, &src);
     375        if (rc != EOK)
     376                return rc;
     377       
     378        uint32_t dest;
     379        rc = inet_addr_pack(&dgram->dest, &dest);
     380        if (rc != EOK)
     381                return rc;
     382       
    367383        async_exch_t *exch = async_exchange_begin(client->sess);
    368 
     384       
    369385        ipc_call_t answer;
    370         aid_t req = async_send_3(exch, INET_EV_RECV, dgram->src.ipv4,
    371             dgram->dest.ipv4, dgram->tos, &answer);
    372         int rc = async_data_write_start(exch, dgram->data, dgram->size);
     386        aid_t req = async_send_3(exch, INET_EV_RECV, (sysarg_t) src,
     387            (sysarg_t) dest, dgram->tos, &answer);
     388        rc = async_data_write_start(exch, dgram->data, dgram->size);
    373389        async_exchange_end(exch);
    374 
     390       
    375391        if (rc != EOK) {
    376392                async_forget(req);
    377393                return rc;
    378394        }
    379 
     395       
    380396        sysarg_t retval;
    381397        async_wait_for(req, &retval);
    382398        if (retval != EOK)
    383399                return retval;
    384 
     400       
    385401        return EOK;
    386402}
  • uspace/srv/net/inetsrv/inetsrv.h

    r19a4f73 ra2e3ee6  
    172172
    173173typedef struct {
    174         inet_addr_t src;
    175         inet_addr_t dest;
     174        uint32_t src;
     175        uint32_t dest;
    176176        uint16_t seq_no;
    177177        void *data;
  • uspace/srv/net/inetsrv/pdu.c

    r19a4f73 ra2e3ee6  
    106106    void **rdata, size_t *rsize, size_t *roffs)
    107107{
    108         void *data;
    109         size_t size;
    110         ip_header_t *hdr;
    111         size_t hdr_size;
    112         size_t data_offs;
    113         uint16_t chksum;
    114         uint16_t ident;
    115         uint16_t flags_foff;
    116         uint16_t foff;
    117         size_t fragoff_limit;
    118         size_t xfer_size;
    119         size_t spc_avail;
    120         size_t rem_offs;
    121 
     108        uint32_t src_addr;
     109        int rc = inet_addr_pack(&packet->src, &src_addr);
     110        if (rc != EOK)
     111                return rc;
     112       
     113        uint32_t dest_addr;
     114        rc = inet_addr_pack(&packet->dest, &dest_addr);
     115        if (rc != EOK)
     116                return rc;
     117       
    122118        /* Upper bound for fragment offset field */
    123         fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
    124 
     119        size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
     120       
    125121        /* Verify that total size of datagram is within reasonable bounds */
    126122        if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
    127123                return ELIMIT;
    128 
    129         hdr_size = sizeof(ip_header_t);
    130         data_offs = ROUND_UP(hdr_size, 4);
    131 
     124       
     125        size_t hdr_size = sizeof(ip_header_t);
     126        size_t data_offs = ROUND_UP(hdr_size, 4);
     127       
    132128        assert(offs % FRAG_OFFS_UNIT == 0);
    133129        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
    134 
     130       
    135131        /* Value for the fragment offset field */
    136         foff = offs / FRAG_OFFS_UNIT;
    137 
     132        uint16_t foff = offs / FRAG_OFFS_UNIT;
     133       
    138134        if (hdr_size >= mtu)
    139135                return EINVAL;
    140 
     136       
    141137        /* Amount of space in the PDU available for payload */
    142         spc_avail = mtu - hdr_size;
     138        size_t spc_avail = mtu - hdr_size;
    143139        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
    144 
     140       
    145141        /* Amount of data (payload) to transfer */
    146         xfer_size = min(packet->size - offs, spc_avail);
    147 
     142        size_t xfer_size = min(packet->size - offs, spc_avail);
     143       
    148144        /* Total PDU size */
    149         size = hdr_size + xfer_size;
    150 
     145        size_t size = hdr_size + xfer_size;
     146       
    151147        /* Offset of remaining payload */
    152         rem_offs = offs + xfer_size;
    153 
     148        size_t rem_offs = offs + xfer_size;
     149       
    154150        /* Flags */
    155         flags_foff =
     151        uint16_t flags_foff =
    156152            (packet->df ? BIT_V(uint16_t, FF_FLAG_DF) : 0) +
    157153            (rem_offs < packet->size ? BIT_V(uint16_t, FF_FLAG_MF) : 0) +
    158154            (foff << FF_FRAGOFF_l);
    159 
    160         data = calloc(size, 1);
     155       
     156        void *data = calloc(size, 1);
    161157        if (data == NULL)
    162158                return ENOMEM;
    163 
     159       
    164160        /* Allocate identifier */
    165161        fibril_mutex_lock(&ip_ident_lock);
    166         ident = ++ip_ident;
     162        uint16_t ident = ++ip_ident;
    167163        fibril_mutex_unlock(&ip_ident_lock);
    168 
     164       
    169165        /* Encode header fields */
    170         hdr = (ip_header_t *)data;
     166        ip_header_t *hdr = (ip_header_t *) data;
     167       
    171168        hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
    172169        hdr->tos = packet->tos;
     
    177174        hdr->proto = packet->proto;
    178175        hdr->chksum = 0;
    179         hdr->src_addr = host2uint32_t_be(packet->src.ipv4);
    180         hdr->dest_addr = host2uint32_t_be(packet->dest.ipv4);
    181 
     176        hdr->src_addr = host2uint32_t_be(src_addr);
     177        hdr->dest_addr = host2uint32_t_be(dest_addr);
     178       
    182179        /* Compute checksum */
    183         chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *)hdr, hdr_size);
     180        uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *) hdr,
     181            hdr_size);
    184182        hdr->chksum = host2uint16_t_be(chksum);
    185 
     183       
    186184        /* Copy payload */
    187         memcpy((uint8_t *)data + data_offs, packet->data + offs, xfer_size);
    188 
     185        memcpy((uint8_t *) data + data_offs, packet->data + offs, xfer_size);
     186       
    189187        *rdata = data;
    190188        *rsize = size;
    191189        *roffs = rem_offs;
    192 
     190       
    193191        return EOK;
    194192}
     
    238236        /* XXX Checksum */
    239237
    240         packet->src.ipv4 = uint32_t_be2host(hdr->src_addr);
    241         packet->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
     238        inet_addr_unpack(uint32_t_be2host(hdr->src_addr), &packet->src);
     239        inet_addr_unpack(uint32_t_be2host(hdr->dest_addr), &packet->dest);
    242240        packet->tos = hdr->tos;
    243241        packet->proto = hdr->proto;
  • uspace/srv/net/inetsrv/reass.c

    r19a4f73 ra2e3ee6  
    139139                    dgram_link);
    140140
    141                 if (f1->packet.src.ipv4 == packet->src.ipv4 &&
    142                     f1->packet.dest.ipv4 == packet->dest.ipv4 &&
    143                     f1->packet.proto == packet->proto &&
    144                     f1->packet.ident == packet->ident) {
     141                if ((inet_addr_compare(&f1->packet.src, &packet->src)) &&
     142                    (inet_addr_compare(&f1->packet.dest, &packet->dest)) &&
     143                    (f1->packet.proto == packet->proto) &&
     144                    (f1->packet.ident == packet->ident)) {
    145145                        /* Match */
    146146                        return rdg;
  • uspace/srv/net/inetsrv/sroute.c

    r19a4f73 ra2e3ee6  
    9797inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
    9898{
    99         uint32_t mask;
    100         inet_sroute_t *best;
    101 
    102         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4);
    103 
    104         fibril_mutex_lock(&sroute_list_lock);
    105 
    106         best = NULL;
    107 
    108         list_foreach(sroute_list, link) {
    109                 inet_sroute_t *sroute = list_get_instance(link,
    110                     inet_sroute_t, sroute_list);
    111 
     99        uint32_t addr_addr;
     100        int rc = inet_addr_pack(addr, &addr_addr);
     101        if (rc != EOK)
     102                return NULL;
     103       
     104        inet_sroute_t *best = NULL;
     105        uint8_t best_bits = 0;
     106       
     107        fibril_mutex_lock(&sroute_list_lock);
     108       
     109        list_foreach(sroute_list, link) {
     110                inet_sroute_t *sroute = list_get_instance(link,
     111                    inet_sroute_t, sroute_list);
     112               
     113                uint32_t dest_addr;
     114                uint8_t dest_bits;
     115                rc = inet_naddr_pack(&sroute->dest, &dest_addr, &dest_bits);
     116                if (rc != EOK)
     117                        continue;
     118               
    112119                /* Look for the most specific route */
    113                 if (best != NULL && best->dest.bits >= sroute->dest.bits)
     120                if ((best != NULL) && (best_bits >= dest_bits))
    114121                        continue;
    115 
    116                 mask = inet_netmask(sroute->dest.bits);
    117                 if ((sroute->dest.ipv4 & mask) == (addr->ipv4 & mask)) {
    118                         fibril_mutex_unlock(&sroute_list_lock);
    119                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found %p",
     122               
     123                uint32_t mask = inet_netmask(dest_bits);
     124                if ((dest_addr & mask) == (addr_addr & mask)) {
     125                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
    120126                            sroute);
    121                         return sroute;
     127                       
     128                        best = sroute;
     129                        best_bits = dest_bits;
    122130                }
    123131        }
    124 
    125         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
    126         fibril_mutex_unlock(&sroute_list_lock);
    127 
    128         return NULL;
     132       
     133        if (best == NULL)
     134                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
     135       
     136        fibril_mutex_unlock(&sroute_list_lock);
     137       
     138        return best;
    129139}
    130140
  • uspace/srv/net/loopip/loopip.c

    r19a4f73 ra2e3ee6  
    5050static int loopip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
    5151static int loopip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    52 static int loopip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr);
    53 static int loopip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr);
     52static int loopip_addr_add(iplink_srv_t *srv, uint32_t addr);
     53static int loopip_addr_remove(iplink_srv_t *srv, uint32_t addr);
    5454
    5555static void loopip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     
    189189}
    190190
    191 static int loopip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    192 {
    193         log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_add(0x%" PRIx32 ")", addr->ipv4);
    194         return EOK;
    195 }
    196 
    197 static int loopip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    198 {
    199         log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_remove(0x%" PRIx32 ")", addr->ipv4);
     191static int loopip_addr_add(iplink_srv_t *srv, uint32_t addr)
     192{
     193        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_add(0x%" PRIx32 ")", addr);
     194        return EOK;
     195}
     196
     197static int loopip_addr_remove(iplink_srv_t *srv, uint32_t addr)
     198{
     199        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_remove(0x%" PRIx32 ")", addr);
    200200        return EOK;
    201201}
  • uspace/srv/net/tcp/conn.c

    r19a4f73 ra2e3ee6  
    312312static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
    313313{
    314         log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    315             sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    316 
    317         if (patt->addr.ipv4 != TCP_IPV4_ANY &&
    318             patt->addr.ipv4 != sock->addr.ipv4)
     314        if ((!inet_addr_is_any(&patt->addr)) &&
     315            (!inet_addr_compare(&patt->addr, &sock->addr)))
    319316                return false;
    320317
    321         if (patt->port != TCP_PORT_ANY &&
    322             patt->port != sock->port)
     318        if ((patt->port != TCP_PORT_ANY) &&
     319            (patt->port != sock->port))
    323320                return false;
    324321
     
    354351{
    355352        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356        
    357         log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare conn (f:(%x,%u), l:(%x,%u))",
    358             sp->foreign.addr.ipv4, sp->foreign.port,
    359             sp->local.addr.ipv4, sp->local.port);
    360353       
    361354        fibril_mutex_lock(&conn_list_lock);
     
    364357                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    365358                tcp_sockpair_t *csp = &conn->ident;
    366                
    367                 log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%x,%u), l:(%x,%u))",
    368                     csp->foreign.addr.ipv4, csp->foreign.port,
    369                     csp->local.addr.ipv4, csp->local.port);
    370359               
    371360                if (tcp_sockpair_match(sp, csp)) {
  • uspace/srv/net/tcp/pdu.c

    r19a4f73 ra2e3ee6  
    146146static void tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr)
    147147{
    148         phdr->src_addr = host2uint32_t_be(pdu->src_addr.ipv4);
    149         phdr->dest_addr = host2uint32_t_be(pdu->dest_addr.ipv4);
     148        // FIXME: Check for correctness
     149       
     150        uint32_t src_addr;
     151        inet_addr_pack(&pdu->src_addr, &src_addr);
     152       
     153        uint32_t dest_addr;
     154        inet_addr_pack(&pdu->dest_addr, &dest_addr);
     155       
     156        phdr->src_addr = host2uint32_t_be(src_addr);
     157        phdr->dest_addr = host2uint32_t_be(dest_addr);
    150158        phdr->zero = 0;
    151159        phdr->protocol = 6; /* XXX Magic number */
  • uspace/srv/net/tcp/sock.c

    r19a4f73 ra2e3ee6  
    179179        }
    180180
    181         sock->laddr.ipv4 = TCP_IPV4_ANY;
     181        inet_addr_any(&sock->laddr);
    182182        sock->lconn = NULL;
    183183        sock->backlog = 0;
     
    314314        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
    315315       
    316         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     316        inet_addr_any(&lsocket.addr);
    317317        lsocket.port = sock_core->port;
    318         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     318       
     319        inet_addr_any(&fsocket.addr);
    319320        fsocket.port = TCP_PORT_ANY;
    320321       
     
    396397        fibril_mutex_lock(&socket->lock);
    397398
    398         if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
     399        if (inet_addr_is_any(&socket->laddr)) {
    399400                /* Determine local IP address */
    400                 inet_addr_t loc_addr, rem_addr;
    401 
    402                 rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     401                inet_addr_t loc_addr;
     402                inet_addr_t rem_addr;
     403               
     404                inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
     405                    &rem_addr);
    403406                rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    404407                if (rc != EOK) {
     
    409412                        return;
    410413                }
    411 
    412                 socket->laddr.ipv4 = loc_addr.ipv4;
    413                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
    414         }
    415 
    416         lsocket.addr.ipv4 = socket->laddr.ipv4;
     414               
     415                socket->laddr = loc_addr;
     416        }
     417       
     418        lsocket.addr = socket->laddr;
    417419        lsocket.port = sock_core->port;
    418         fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     420       
     421        inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
     422            &fsocket.addr);
    419423        fsocket.port = uint16_t_be2host(addr->sin_port);
    420424
     
    507511        /* Replenish listening connection */
    508512
    509         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     513        inet_addr_any(&lsocket.addr);
    510514        lsocket.port = sock_core->port;
    511         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     515       
     516        inet_addr_any(&fsocket.addr);
    512517        fsocket.port = TCP_PORT_ANY;
    513518
     
    728733
    729734        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    730                 /* Fill addr */
     735                /* Fill address */
    731736                rsock = &socket->conn->ident.foreign;
     737               
     738                uint32_t rsock_addr;
     739                int rc = inet_addr_pack(&rsock->addr, &rsock_addr);
     740                if (rc != EOK) {
     741                        fibril_mutex_unlock(&socket->recv_buffer_lock);
     742                        fibril_mutex_unlock(&socket->lock);
     743                        async_answer_0(callid, rc);
     744                        return;
     745                }
     746               
    732747                addr.sin_family = AF_INET;
    733                 addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4);
     748                addr.sin_addr.s_addr = host2uint32_t_be(rsock_addr);
    734749                addr.sin_port = host2uint16_t_be(rsock->port);
    735750
  • uspace/srv/net/tcp/tcp.c

    r19a4f73 ra2e3ee6  
    115115        }
    116116
    117         pdu->src_addr.ipv4 = dgram->src.ipv4;
    118         pdu->dest_addr.ipv4 = dgram->dest.ipv4;
    119         log_msg(LOG_DEFAULT, LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
    120             pdu->src_addr.ipv4, pdu->dest_addr.ipv4);
     117        pdu->src_addr = dgram->src;
     118        pdu->dest_addr = dgram->dest;
    121119
    122120        tcp_received_pdu(pdu);
     
    145143            pdu->text_size);
    146144
    147         dgram.src.ipv4 = pdu->src_addr.ipv4;
    148         dgram.dest.ipv4 = pdu->dest_addr.ipv4;
     145        dgram.src = pdu->src_addr;
     146        dgram.dest = pdu->dest_addr;
    149147        dgram.tos = 0;
    150148        dgram.data = pdu_raw;
  • uspace/srv/net/tcp/tcp_type.h

    r19a4f73 ra2e3ee6  
    4343#include <socket_core.h>
    4444#include <sys/types.h>
     45#include <inet/addr.h>
    4546
    4647struct tcp_conn;
     
    112113
    113114typedef struct {
    114         uint32_t ipv4;
    115 } netaddr_t;
    116 
    117 typedef struct {
    118         netaddr_t addr;
     115        inet_addr_t addr;
    119116        uint16_t port;
    120117} tcp_sock_t;
    121 
    122 enum netaddr {
    123         TCP_IPV4_ANY = 0
    124 };
    125118
    126119enum tcp_port {
     
    313306typedef struct {
    314307        /** Source address */
    315         netaddr_t src_addr;
     308        inet_addr_t src_addr;
    316309        /** Destination address */
    317         netaddr_t dest_addr;
    318 
     310        inet_addr_t dest_addr;
     311       
    319312        /** Encoded header */
    320313        void *header;
     
    344337        tcp_conn_t *conn;
    345338        /** Local address */
    346         netaddr_t laddr;
     339        inet_addr_t laddr;
    347340        /** Backlog size */
    348341        int backlog;
  • uspace/srv/net/tcp/test.c

    r19a4f73 ra2e3ee6  
    5757
    5858        printf("test_srv()\n");
     59       
     60        inet_addr(&lsock.addr, 127, 0, 0, 1);
    5961        lsock.port = 80;
    60         lsock.addr.ipv4 = 0x7f000001;
     62       
     63        inet_addr(&fsock.addr, 127, 0, 0, 1);
    6164        fsock.port = 1024;
    62         fsock.addr.ipv4 = 0x7f000001;
     65       
    6366        printf("S: User open...\n");
    6467        tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn);
     
    9598
    9699        printf("test_cli()\n");
    97 
     100       
     101        inet_addr(&lsock.addr, 127, 0, 0, 1);
    98102        lsock.port = 1024;
    99         lsock.addr.ipv4 = 0x7f000001;
     103       
     104        inet_addr(&fsock.addr, 127, 0, 0, 1);
    100105        fsock.port = 80;
    101         fsock.addr.ipv4 = 0x7f000001;
    102106
    103107        async_usleep(1000*1000*3);
  • uspace/srv/net/tcp/tqueue.c

    r19a4f73 ra2e3ee6  
    282282void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
    283283{
    284         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)",
    285             sp->foreign.addr.ipv4, sp->foreign.port,
    286             sp->local.addr.ipv4, sp->local.port, seg);
    287 
    288284        log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
    289285            seg->seq, seg->wnd);
  • uspace/srv/net/tcp/ucall.c

    r19a4f73 ra2e3ee6  
    298298        tcp_conn_t *conn;
    299299
    300         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))",
    301             sp->foreign.addr.ipv4, sp->foreign.port,
    302             sp->local.addr.ipv4, sp->local.port);
    303 
    304300        conn = tcp_conn_find_ref(sp);
    305301        if (conn == NULL) {
     
    319315        }
    320316
    321         if (conn->ident.foreign.addr.ipv4 == TCP_IPV4_ANY)
    322                 conn->ident.foreign.addr.ipv4 = sp->foreign.addr.ipv4;
     317        if (inet_addr_is_any(&conn->ident.foreign.addr))
     318                conn->ident.foreign.addr = sp->foreign.addr;
     319       
    323320        if (conn->ident.foreign.port == TCP_PORT_ANY)
    324321                conn->ident.foreign.port = sp->foreign.port;
    325         if (conn->ident.local.addr.ipv4 == TCP_IPV4_ANY)
    326                 conn->ident.local.addr.ipv4 = sp->local.addr.ipv4;
     322       
     323        if (inet_addr_is_any(&conn->ident.local.addr))
     324                conn->ident.local.addr = sp->local.addr;
    327325
    328326        tcp_conn_segment_arrived(conn, seg);
  • uspace/srv/net/udp/assoc.c

    r19a4f73 ra2e3ee6  
    252252                sp.foreign = *fsock;
    253253
    254         if ((inet2_addr_is_any(&sp.foreign.addr)) ||
     254        if ((inet_addr_is_any(&sp.foreign.addr)) ||
    255255            (sp.foreign.port == UDP_PORT_ANY))
    256256                return EINVAL;
     
    372372static bool udp_socket_match(udp_sock_t *sock, udp_sock_t *patt)
    373373{
    374         if ((!inet2_addr_is_any(&patt->addr)) &&
    375             (!inet2_addr_compare(&patt->addr, &sock->addr)))
     374        if ((!inet_addr_is_any(&patt->addr)) &&
     375            (!inet_addr_compare(&patt->addr, &sock->addr)))
    376376                return false;
    377377       
  • uspace/srv/net/udp/pdu.c

    r19a4f73 ra2e3ee6  
    8989       
    9090        uint32_t src;
    91         inet2_addr_pack(&pdu->src, &src);
     91        inet_addr_pack(&pdu->src, &src);
    9292       
    9393        uint32_t dest;
    94         inet2_addr_pack(&pdu->dest, &dest);
     94        inet_addr_pack(&pdu->dest, &dest);
    9595       
    9696        phdr->src_addr = host2uint32_t_be(src);
  • uspace/srv/net/udp/sock.c

    r19a4f73 ra2e3ee6  
    201201        socket = (udp_sockdata_t *) sock_core->specific_data;
    202202       
    203         inet2_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
     203        inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
    204204            &fsock.addr);
    205205        fsock.port = sock_core->port;
     
    270270                }
    271271               
    272                 inet2_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
     272                inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
    273273                    &fsock.addr);
    274274                fsock.port = uint16_t_be2host(addr->sin_port);
     
    316316        fibril_mutex_lock(&socket->lock);
    317317       
    318         if (inet2_addr_is_any(&socket->assoc->ident.local.addr)) {
     318        if (inet_addr_is_any(&socket->assoc->ident.local.addr)) {
    319319                /* Determine local IP address */
    320                 inet2_addr_t loc_addr;
    321                 inet2_addr_t rem_addr;
     320                inet_addr_t loc_addr;
     321                inet_addr_t rem_addr;
    322322               
    323323                rem_addr = fsock_ptr ? fsock.addr :
    324324                    socket->assoc->ident.foreign.addr;
    325325               
    326                 int rc = inet2_get_srcaddr(&rem_addr, 0, &loc_addr);
     326                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    327327                if (rc != EOK) {
    328328                        fibril_mutex_unlock(&socket->lock);
     
    479479                /* Fill address */
    480480                uint32_t rsock_addr;
    481                 int rc = inet2_addr_pack(&rsock->addr, &rsock_addr);
     481                int rc = inet_addr_pack(&rsock->addr, &rsock_addr);
    482482                if (rc != EOK) {
    483483                        fibril_mutex_unlock(&socket->recv_buffer_lock);
  • uspace/srv/net/udp/udp_inet.c

    r19a4f73 ra2e3ee6  
    6666        pdu->data = dgram->data;
    6767        pdu->data_size = dgram->size;
    68        
    69         inet_inet2(&dgram->src, &pdu->src);
    70         inet_inet2(&dgram->dest, &pdu->dest);
     68
     69        pdu->src = dgram->src;
     70        pdu->dest = dgram->dest;
    7171
    7272        udp_received_pdu(pdu);
     
    8484        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_transmit_pdu()");
    8585
    86         inet2_inet(&pdu->src, &dgram.src);
    87         inet2_inet(&pdu->dest, &dgram.dest);
     86        dgram.src = pdu->src;
     87        dgram.dest = pdu->dest;
    8888        dgram.tos = 0;
    8989        dgram.data = pdu->data;
  • uspace/srv/net/udp/udp_type.h

    r19a4f73 ra2e3ee6  
    4040#include <socket_core.h>
    4141#include <sys/types.h>
    42 #include <inet/addr2.h>
     42#include <inet/addr.h>
    4343
    4444#define UDP_FRAGMENT_SIZE 4096
     
    6666
    6767typedef struct {
    68         inet2_addr_t addr;
     68        inet_addr_t addr;
    6969        uint16_t port;
    7070} udp_sock_t;
     
    8686typedef struct {
    8787        /** Source address */
    88         inet2_addr_t src;
     88        inet_addr_t src;
    8989        /** Destination address */
    90         inet2_addr_t dest;
     90        inet_addr_t dest;
    9191       
    9292        /** Encoded PDU data including header */
Note: See TracChangeset for help on using the changeset viewer.