Changeset a2e3ee6 in mainline for uspace/srv/net


Ignore:
Timestamp:
2013-06-20T16:45:58Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
08bb73b
Parents:
19a4f73
Message:

use new network address infrastructure (towards IPv6 support)

Location:
uspace/srv/net
Files:
39 edited

Legend:

Unmodified
Added
Removed

  • 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.