Changeset 02a09ed in mainline for uspace/srv/net/inetsrv


Ignore:
Timestamp:
2013-06-28T20:20:03Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1d24ad3
Parents:
edf0d27
Message:

add basic infrastructure for IPv6 (inactive)
make inet_addr_t a universal address type

Location:
uspace/srv/net/inetsrv
Files:
2 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/inetsrv/Makefile

    redf0d27 r02a09ed  
    3535        inetsrv.c \
    3636        inet_link.c \
    37         inet_util.c \
    3837        inetcfg.c \
    3938        inetping.c \

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

    redf0d27 r02a09ed  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 
    4544#include "addrobj.h"
    4645#include "inetsrv.h"
    4746#include "inet_link.h"
    48 #include "inet_util.h"
    4947
    5048static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *, inet_link_t *);
    … …  
    106104/** Find address object matching address @a addr.
    107105 *
    108  * @param addr  Address
    109  * @oaram find  iaf_net to find network (using mask),
    110  *              iaf_addr to find local address (exact match)
     106 * @param addr Address
     107 * @oaram find iaf_net to find network (using mask),
     108 *             iaf_addr to find local address (exact match)
     109 *
    111110 */
    112111inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
    113112{
    114         uint32_t addr_addr;
    115         int rc = inet_addr_pack(addr, &addr_addr);
    116         if (rc != EOK)
    117                 return NULL;
    118        
    119113        fibril_mutex_lock(&addr_list_lock);
    120114       
    … …  
    123117                    inet_addrobj_t, addr_list);
    124118               
    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)) {
     119                if (inet_naddr_compare_mask(&naddr->naddr, addr)) {
    133120                        fibril_mutex_unlock(&addr_list_lock);
    134121                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
    … …  
    227214        inet_naddr_addr(&addr->naddr, &lsrc_addr);
    228215       
    229         inet_addr_t *ldest_addr = ldest;
    230        
    231         return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest_addr, dgram,
     216        return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest, dgram,
    232217            proto, ttl, df);
    233218}

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

    redf0d27 r02a09ed  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 
     42#include <net/socket_codes.h>
    4343#include "icmp.h"
    4444#include "icmp_std.h"
    … …  
    129129        inetping_sdu_t sdu;
    130130       
    131         int rc = inet_addr_pack(&dgram->src, &sdu.src);
    132         if (rc != EOK)
    133                 return rc;
     131        uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
     132        if (family != AF_INET)
     133                return EINVAL;
    134134       
    135         rc = inet_addr_pack(&dgram->dest, &sdu.dest);
    136         if (rc != EOK)
    137                 return rc;
     135        family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
     136        if (family != AF_INET)
     137                return EINVAL;
    138138       
    139139        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    … …  
    168168        inet_dgram_t dgram;
    169169       
    170         inet_addr_unpack(sdu->src, &dgram.src);
    171         inet_addr_unpack(sdu->dest, &dgram.dest);
     170        inet_addr_set(sdu->src, &dgram.src);
     171        inet_addr_set(sdu->dest, &dgram.dest);
    172172       
    173173        dgram.tos = ICMP_TOS;

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

    redf0d27 r02a09ed  
    4343#include <stdlib.h>
    4444#include <str.h>
    45 
     45#include <net/socket_codes.h>
    4646#include "addrobj.h"
    4747#include "inetsrv.h"
    … …  
    4949#include "pdu.h"
    5050
    51 static int inet_link_open(service_id_t sid);
    52 static int inet_iplink_recv(iplink_t *ilink, iplink_sdu_t *sdu);
     51static int inet_link_open(service_id_t);
     52static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, uint16_t);
    5353
    5454static iplink_ev_ops_t inet_iplink_ev_ops = {
    … …  
    5959static FIBRIL_MUTEX_INITIALIZE(inet_discovery_lock);
    6060
    61 static int inet_iplink_recv(iplink_t *iplink, iplink_sdu_t *sdu)
    62 {
     61static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, uint16_t af)
     62{
     63        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
     64       
     65        int rc;
    6366        inet_packet_t packet;
    64         int rc;
    65 
    66         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
    67         rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
     67       
     68        switch (af) {
     69        case AF_INET:
     70                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
     71                break;
     72        case AF_INET6:
     73                // FIXME TODO
     74                return ENOTSUP;
     75        default:
     76                log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid address family");
     77                return EINVAL;
     78        }
     79       
    6880        if (rc != EOK) {
    6981                log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU");
    … …  
    228240
    229241        return EOK;
    230 
     242       
    231243error:
    232244        if (ilink->iplink != NULL)
    … …  
    277289       
    278290        iplink_sdu_t sdu;
    279        
    280         int rc = inet_addr_pack(lsrc, &sdu.lsrc);
    281         if (rc != EOK)
    282                 return rc;
    283        
    284         rc = inet_addr_pack(ldest, &sdu.ldest);
    285         if (rc != EOK)
    286                 return rc;
    287        
    288291        size_t offs = 0;
     292        int rc;
     293       
     294        sdu.src = *lsrc;
     295        sdu.dest = *ldest;
     296       
    289297        do {
     298                /* Encode one fragment */
    290299                size_t roffs;
    291                
    292                 /* Encode one fragment */
    293300                rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
    294301                    &sdu.size, &roffs);

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

    redf0d27 r02a09ed  
    236236}
    237237
    238 static void inetcfg_addr_create_static_srv(ipc_callid_t callid,
    239     ipc_call_t *call)
    240 {
     238static void inetcfg_addr_create_static_srv(ipc_callid_t iid,
     239    ipc_call_t *icall)
     240{
     241        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
     242       
     243        sysarg_t link_id = IPC_GET_ARG1(*icall);
     244       
     245        ipc_callid_t callid;
     246        size_t size;
     247        if (!async_data_write_receive(&callid, &size)) {
     248                async_answer_0(callid, EINVAL);
     249                async_answer_0(iid, EINVAL);
     250                return;
     251        }
     252       
     253        if (size != sizeof(inet_naddr_t)) {
     254                async_answer_0(callid, EINVAL);
     255                async_answer_0(iid, EINVAL);
     256                return;
     257        }
     258       
     259        inet_naddr_t naddr;
     260        int rc = async_data_write_finalize(callid, &naddr, size);
     261        if (rc != EOK) {
     262                async_answer_0(callid, rc);
     263                async_answer_0(iid, rc);
     264                return;
     265        }
     266       
    241267        char *name;
    242         inet_naddr_t naddr;
    243         sysarg_t link_id;
    244         sysarg_t addr_id;
    245         int rc;
    246 
    247         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
    248 
    249268        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    250269            0, NULL);
    251270        if (rc != EOK) {
    252                 async_answer_0(callid, rc);
    253                 return;
    254         }
    255 
    256         inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &naddr);
    257         link_id = IPC_GET_ARG3(*call);
    258 
    259         addr_id = 0;
     271                async_answer_0(iid, rc);
     272                return;
     273        }
     274       
     275        sysarg_t addr_id = 0;
    260276        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    261277        free(name);
    262         async_answer_1(callid, rc, addr_id);
     278        async_answer_1(iid, rc, addr_id);
    263279}
    264280
    … …  
    276292}
    277293
    278 static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
     294static void inetcfg_addr_get_srv(ipc_callid_t iid, ipc_call_t *icall)
    279295{
    280296        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    281297       
    282         sysarg_t addr_id = IPC_GET_ARG1(*call);
     298        sysarg_t addr_id = IPC_GET_ARG1(*icall);
    283299       
    284300        inet_addr_info_t ainfo;
    … …  
    288304        ainfo.name = NULL;
    289305       
    290         ipc_callid_t rcallid;
    291         size_t max_size;
    292        
    293         if (!async_data_read_receive(&rcallid, &max_size)) {
    294                 async_answer_0(rcallid, EREFUSED);
    295                 async_answer_0(callid, EREFUSED);
    296                 return;
    297         }
    298        
    299306        int rc = inetcfg_addr_get(addr_id, &ainfo);
    300307        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        
    313         sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
    314             min(max_size, str_size(ainfo.name)));
     308                async_answer_0(iid, rc);
     309                return;
     310        }
     311       
     312        ipc_callid_t callid;
     313        size_t size;
     314        if (!async_data_read_receive(&callid, &size)) {
     315                async_answer_0(callid, EREFUSED);
     316                async_answer_0(iid, EREFUSED);
     317                return;
     318        }
     319       
     320        if (size != sizeof(inet_naddr_t)) {
     321                async_answer_0(callid, EINVAL);
     322                async_answer_0(iid, EINVAL);
     323                return;
     324        }
     325       
     326        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
     327        if (rc != EOK) {
     328                async_answer_0(callid, rc);
     329                async_answer_0(iid, rc);
     330                return;
     331        }
     332       
     333        if (!async_data_read_receive(&callid, &size)) {
     334                async_answer_0(callid, EREFUSED);
     335                async_answer_0(iid, EREFUSED);
     336                return;
     337        }
     338       
     339        rc = async_data_read_finalize(callid, ainfo.name,
     340            min(size, str_size(ainfo.name)));
    315341        free(ainfo.name);
    316342       
    317         async_answer_3(callid, retval, (sysarg_t) naddr_addr,
    318             (sysarg_t) naddr_bits, ainfo.ilink);
     343        if (rc != EOK) {
     344                async_answer_0(callid, rc);
     345                async_answer_0(iid, rc);
     346                return;
     347        }
     348       
     349        async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
    319350}
    320351
    … …  
    477508}
    478509
    479 static void inetcfg_sroute_create_srv(ipc_callid_t callid,
    480     ipc_call_t *call)
     510static void inetcfg_sroute_create_srv(ipc_callid_t iid,
     511    ipc_call_t *icall)
    481512{
    482513        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
     514
     515        ipc_callid_t callid;
     516        size_t size;
     517        if (!async_data_write_receive(&callid, &size)) {
     518                async_answer_0(callid, EINVAL);
     519                async_answer_0(iid, EINVAL);
     520                return;
     521        }
     522       
     523        if (size != sizeof(inet_naddr_t)) {
     524                async_answer_0(callid, EINVAL);
     525                async_answer_0(iid, EINVAL);
     526                return;
     527        }
     528       
     529        inet_naddr_t dest;
     530        int rc = async_data_write_finalize(callid, &dest, size);
     531        if (rc != EOK) {
     532                async_answer_0(callid, rc);
     533                async_answer_0(iid, rc);
     534                return;
     535        }
     536       
     537        if (!async_data_write_receive(&callid, &size)) {
     538                async_answer_0(callid, EINVAL);
     539                async_answer_0(iid, EINVAL);
     540                return;
     541        }
     542       
     543        if (size != sizeof(inet_addr_t)) {
     544                async_answer_0(callid, EINVAL);
     545                async_answer_0(iid, EINVAL);
     546                return;
     547        }
     548       
     549        inet_addr_t router;
     550        rc = async_data_write_finalize(callid, &router, size);
     551        if (rc != EOK) {
     552                async_answer_0(callid, rc);
     553                async_answer_0(iid, rc);
     554                return;
     555        }
    483556       
    484557        char *name;
    485         int rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
     558        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    486559            0, NULL);
    487560        if (rc != EOK) {
    488                 async_answer_0(callid, rc);
    489                 return;
    490         }
    491        
    492         inet_naddr_t dest;
    493         inet_addr_t router;
    494        
    495         inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &dest);
    496         inet_addr_unpack(IPC_GET_ARG3(*call), &router);
     561                async_answer_0(iid, rc);
     562                return;
     563        }
    497564       
    498565        sysarg_t sroute_id = 0;
    499566        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    500567        free(name);
    501         async_answer_1(callid, rc, sroute_id);
     568        async_answer_1(iid, rc, sroute_id);
    502569}
    503570
    … …  
    515582}
    516583
    517 static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
     584static void inetcfg_sroute_get_srv(ipc_callid_t iid, ipc_call_t *icall)
    518585{
    519586        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    520587       
    521         sysarg_t sroute_id = IPC_GET_ARG1(*call);
     588        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
    522589       
    523590        inet_sroute_info_t srinfo;
    … …  
    527594        srinfo.name = NULL;
    528595       
    529         ipc_callid_t rcallid;
    530         size_t max_size;
    531         if (!async_data_read_receive(&rcallid, &max_size)) {
    532                 async_answer_0(rcallid, EREFUSED);
    533                 async_answer_0(callid, EREFUSED);
    534                 return;
    535         }
    536        
    537596        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
    538597        if (rc != EOK) {
    539                 async_answer_0(callid, rc);
    540                 return;
    541         }
    542        
    543         uint32_t dest_addr;
    544         uint8_t dest_bits;
    545         rc = inet_naddr_pack(&srinfo.dest, &dest_addr, &dest_bits);
    546         if (rc != EOK) {
    547                 async_answer_0(callid, rc);
    548                 return;
    549         }
    550        
    551         uint32_t router_addr;
    552         rc = inet_addr_pack(&srinfo.router, &router_addr);
    553         if (rc != EOK) {
    554                 async_answer_0(callid, rc);
    555                 return;
    556         }
    557        
    558         sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
    559             min(max_size, str_size(srinfo.name)));
     598                async_answer_0(iid, rc);
     599                return;
     600        }
     601       
     602        ipc_callid_t callid;
     603        size_t size;
     604        if (!async_data_read_receive(&callid, &size)) {
     605                async_answer_0(callid, EREFUSED);
     606                async_answer_0(iid, EREFUSED);
     607                return;
     608        }
     609       
     610        if (size != sizeof(inet_naddr_t)) {
     611                async_answer_0(callid, EINVAL);
     612                async_answer_0(iid, EINVAL);
     613                return;
     614        }
     615       
     616        rc = async_data_read_finalize(callid, &srinfo.dest, size);
     617        if (rc != EOK) {
     618                async_answer_0(callid, rc);
     619                async_answer_0(iid, rc);
     620                return;
     621        }
     622       
     623        if (!async_data_read_receive(&callid, &size)) {
     624                async_answer_0(callid, EREFUSED);
     625                async_answer_0(iid, EREFUSED);
     626                return;
     627        }
     628       
     629        if (size != sizeof(inet_addr_t)) {
     630                async_answer_0(callid, EINVAL);
     631                async_answer_0(iid, EINVAL);
     632                return;
     633        }
     634       
     635        rc = async_data_read_finalize(callid, &srinfo.router, size);
     636        if (rc != EOK) {
     637                async_answer_0(callid, rc);
     638                async_answer_0(iid, rc);
     639                return;
     640        }
     641       
     642        if (!async_data_read_receive(&callid, &size)) {
     643                async_answer_0(callid, EREFUSED);
     644                async_answer_0(iid, EREFUSED);
     645                return;
     646        }
     647       
     648        rc = async_data_read_finalize(callid, srinfo.name,
     649            min(size, str_size(srinfo.name)));
    560650        free(srinfo.name);
    561651       
    562         async_answer_3(callid, retval, (sysarg_t) dest_addr,
    563             (sysarg_t) dest_bits, (sysarg_t) router_addr);
     652        async_answer_0(iid, (sysarg_t) rc);
    564653}
    565654

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

    redf0d27 r02a09ed  
    4343#include <stdlib.h>
    4444#include <sys/types.h>
    45 
     45#include <net/socket_codes.h>
    4646#include "icmp.h"
    4747#include "icmp_std.h"
    … …  
    5555static uint16_t inetping_ident = 0;
    5656
    57 static inetping_client_t *inetping_client_find(uint16_t);
    58 
    5957static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    6058{
    … …  
    6260}
    6361
    64 static int inetping_get_srcaddr(inetping_client_t *client, uint32_t remote,
    65     uint32_t *local)
     62static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
     63    addr32_t *local)
    6664{
    6765        inet_addr_t remote_addr;
    68         inet_addr_unpack(remote, &remote_addr);
     66        inet_addr_set(remote, &remote_addr);
    6967       
    7068        inet_addr_t local_addr;
    … …  
    7371                return rc;
    7472       
    75         return inet_addr_pack(&local_addr, local);
     73        uint16_t family = inet_addr_get(&local_addr, local, NULL);
     74        if (family != AF_INET)
     75                return EINVAL;
     76       
     77        return EOK;
     78}
     79
     80static inetping_client_t *inetping_client_find(uint16_t ident)
     81{
     82        fibril_mutex_lock(&client_list_lock);
     83       
     84        list_foreach(client_list, link) {
     85                inetping_client_t *client = list_get_instance(link,
     86                    inetping_client_t, client_list);
     87               
     88                if (client->ident == ident) {
     89                        fibril_mutex_unlock(&client_list_lock);
     90                        return client;
     91                }
     92        }
     93       
     94        fibril_mutex_unlock(&client_list_lock);
     95        return NULL;
    7696}
    7797
    7898int inetping_recv(uint16_t ident, inetping_sdu_t *sdu)
    7999{
    80         inetping_client_t *client;
    81         async_exch_t *exch;
    82         ipc_call_t answer;
    83 
    84         client = inetping_client_find(ident);
     100        inetping_client_t *client = inetping_client_find(ident);
    85101        if (client == NULL) {
    86102                log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ICMP ident. Dropping.");
    87103                return ENOENT;
    88104        }
    89 
    90         exch = async_exchange_begin(client->sess);
    91 
     105       
     106        async_exch_t *exch = async_exchange_begin(client->sess);
     107       
     108        ipc_call_t answer;
    92109        aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
    93110            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    94111        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     112       
    95113        async_exchange_end(exch);
    96114       
    … …  
    170188}
    171189
    172 static inetping_client_t *inetping_client_find(uint16_t ident)
    173 {
    174         fibril_mutex_lock(&client_list_lock);
    175 
    176         list_foreach(client_list, link) {
    177                 inetping_client_t *client = list_get_instance(link,
    178                     inetping_client_t, client_list);
    179 
    180                 if (client->ident == ident) {
    181                         fibril_mutex_unlock(&client_list_lock);
    182                         return client;
    183                 }
    184         }
    185 
    186         fibril_mutex_unlock(&client_list_lock);
    187         return NULL;
    188 }
    189 
    190190void inetping_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    191191{
    192         inetping_client_t client;
    193         int rc;
    194 
    195192        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    196 
     193       
    197194        /* Accept the connection */
    198195        async_answer_0(iid, EOK);
    199 
    200         rc = inetping_client_init(&client);
     196       
     197        inetping_client_t client;
     198        int rc = inetping_client_init(&client);
    201199        if (rc != EOK)
    202200                return;

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

    redf0d27 r02a09ed  
    4646#include <stdlib.h>
    4747#include <sys/types.h>
    48 
     48#include <net/socket_codes.h>
    4949#include "addrobj.h"
    5050#include "icmp.h"
    … …  
    202202        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
    203203       
     204        addr32_t remote_v4 = IPC_GET_ARG1(*call);
     205        uint8_t tos = IPC_GET_ARG2(*call);
     206       
    204207        inet_addr_t remote;
    205         inet_addr_unpack(IPC_GET_ARG1(*call), &remote);
    206         uint8_t tos = IPC_GET_ARG2(*call);
     208        inet_addr_set(remote_v4, &remote);
    207209       
    208210        inet_addr_t local;
    … …  
    213215        }
    214216       
    215         uint32_t local_addr;
    216         rc = inet_addr_pack(&local, &local_addr);
    217         if (rc != EOK) {
    218                 async_answer_0(callid, rc);
     217        addr32_t local_v4;
     218        uint16_t family = inet_addr_get(&local, &local_v4, NULL);
     219        if (family != AF_INET) {
     220                async_answer_0(callid, EINVAL);
    219221                return;
    220222        }
    221223       
    222         async_answer_1(callid, rc, (sysarg_t) local_addr);
     224        async_answer_1(callid, rc, (sysarg_t) local_v4);
    223225}
    224226
    … …  
    228230        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
    229231       
     232        addr32_t src_v4 = IPC_GET_ARG1(*call);
     233        addr32_t dest_v4 = IPC_GET_ARG2(*call);
     234       
    230235        inet_dgram_t dgram;
    231236       
    232         inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
    233         inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
     237        inet_addr_set(src_v4, &dgram.src);
     238        inet_addr_set(dest_v4, &dgram.dest);
    234239        dgram.tos = IPC_GET_ARG3(*call);
    235240       
    … …  
    371376int inet_ev_recv(inet_client_t *client, inet_dgram_t *dgram)
    372377{
    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        
    383378        async_exch_t *exch = async_exchange_begin(client->sess);
    384379       
    385380        ipc_call_t answer;
    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);
    389         async_exchange_end(exch);
    390        
    391         if (rc != EOK) {
     381        aid_t req = async_send_1(exch, INET_EV_RECV, dgram->tos, &answer);
     382       
     383        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
     384        if (rc != EOK) {
     385                async_exchange_end(exch);
    392386                async_forget(req);
    393387                return rc;
    394388        }
    395389       
     390        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
     391        if (rc != EOK) {
     392                async_exchange_end(exch);
     393                async_forget(req);
     394                return rc;
     395        }
     396       
     397        rc = async_data_write_start(exch, dgram->data, dgram->size);
     398       
     399        async_exchange_end(exch);
     400       
     401        if (rc != EOK) {
     402                async_forget(req);
     403                return rc;
     404        }
     405       
    396406        sysarg_t retval;
    397407        async_wait_for(req, &retval);
    398         if (retval != EOK)
    399                 return retval;
    400        
    401         return EOK;
     408       
     409        return (int) retval;
    402410}
    403411

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

    redf0d27 r02a09ed  
    4444#include <mem.h>
    4545#include <stdlib.h>
    46 
     46#include <net/socket_codes.h>
    4747#include "inetsrv.h"
    4848#include "inet_std.h"
    … …  
    106106    void **rdata, size_t *rsize, size_t *roffs)
    107107{
    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;
     108        addr32_t src_v4;
     109        addr128_t src_v6;
     110        uint16_t src_af = inet_addr_get(&packet->src, &src_v4, &src_v6);
     111       
     112        addr32_t dest_v4;
     113        addr128_t dest_v6;
     114        uint16_t dest_af = inet_addr_get(&packet->dest, &dest_v4, &dest_v6);
     115       
     116        if (src_af != dest_af)
     117                return EINVAL;
    117118       
    118119        /* Upper bound for fragment offset field */
    … …  
    123124                return ELIMIT;
    124125       
    125         size_t hdr_size = sizeof(ip_header_t);
     126        size_t hdr_size;
     127       
     128        switch (src_af) {
     129        case AF_INET:
     130                hdr_size = sizeof(ip_header_t);
     131                break;
     132        case AF_INET6:
     133                // FIXME TODO
     134                assert(false);
     135        default:
     136                assert(false);
     137        }
     138       
    126139        size_t data_offs = ROUND_UP(hdr_size, 4);
    127140       
    … …  
    164177       
    165178        /* Encode header fields */
    166         ip_header_t *hdr = (ip_header_t *) data;
    167        
    168         hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
    169         hdr->tos = packet->tos;
    170         hdr->tot_len = host2uint16_t_be(size);
    171         hdr->id = host2uint16_t_be(ident);
    172         hdr->flags_foff = host2uint16_t_be(flags_foff);
    173         hdr->ttl = packet->ttl;
    174         hdr->proto = packet->proto;
    175         hdr->chksum = 0;
    176         hdr->src_addr = host2uint32_t_be(src_addr);
    177         hdr->dest_addr = host2uint32_t_be(dest_addr);
    178        
    179         /* Compute checksum */
    180         uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *) hdr,
    181             hdr_size);
    182         hdr->chksum = host2uint16_t_be(chksum);
     179        ip_header_t *hdr;
     180       
     181        switch (src_af) {
     182        case AF_INET:
     183                hdr = (ip_header_t *) data;
     184               
     185                hdr->ver_ihl =
     186                    (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
     187                hdr->tos = packet->tos;
     188                hdr->tot_len = host2uint16_t_be(size);
     189                hdr->id = host2uint16_t_be(ident);
     190                hdr->flags_foff = host2uint16_t_be(flags_foff);
     191                hdr->ttl = packet->ttl;
     192                hdr->proto = packet->proto;
     193                hdr->chksum = 0;
     194                hdr->src_addr = host2uint32_t_be(src_v4);
     195                hdr->dest_addr = host2uint32_t_be(dest_v4);
     196               
     197                /* Compute checksum */
     198                uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT,
     199                    (void *) hdr, hdr_size);
     200                hdr->chksum = host2uint16_t_be(chksum);
     201               
     202                break;
     203        case AF_INET6:
     204                // FIXME TODO
     205                return ENOTSUP;
     206        default:
     207                assert(false);
     208        }
    183209       
    184210        /* Copy payload */
    … …  
    194220int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
    195221{
    196         ip_header_t *hdr;
    197         size_t tot_len;
    198         size_t data_offs;
    199         uint8_t version;
    200         uint16_t ident;
    201         uint16_t flags_foff;
    202         uint16_t foff;
    203 
    204222        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
    205223       
    … …  
    208226                return EINVAL;
    209227        }
    210 
    211         hdr = (ip_header_t *)data;
    212 
    213         version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h, VI_VERSION_l,
    214             hdr->ver_ihl);
     228       
     229        ip_header_t *hdr = (ip_header_t *) data;
     230       
     231        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
     232            VI_VERSION_l, hdr->ver_ihl);
    215233        if (version != 4) {
    216234                log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 4", version);
    217235                return EINVAL;
    218236        }
    219 
    220         tot_len = uint16_t_be2host(hdr->tot_len);
     237       
     238        size_t tot_len = uint16_t_be2host(hdr->tot_len);
    221239        if (tot_len < sizeof(ip_header_t)) {
    222240                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length too small (%zu)", tot_len);
    … …  
    229247                return EINVAL;
    230248        }
    231 
    232         ident = uint16_t_be2host(hdr->id);
    233         flags_foff = uint16_t_be2host(hdr->flags_foff);
    234         foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
     249       
     250        uint16_t ident = uint16_t_be2host(hdr->id);
     251        uint16_t flags_foff = uint16_t_be2host(hdr->flags_foff);
     252        uint16_t foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
    235253            flags_foff);
    236254        /* XXX Checksum */
    237 
    238         inet_addr_unpack(uint32_t_be2host(hdr->src_addr), &packet->src);
    239         inet_addr_unpack(uint32_t_be2host(hdr->dest_addr), &packet->dest);
     255       
     256        inet_addr_set(uint32_t_be2host(hdr->src_addr), &packet->src);
     257        inet_addr_set(uint32_t_be2host(hdr->dest_addr), &packet->dest);
    240258        packet->tos = hdr->tos;
    241259        packet->proto = hdr->proto;
    … …  
    248266       
    249267        /* XXX IP options */
    250         data_offs = sizeof(uint32_t) * BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h,
    251             VI_IHL_l, hdr->ver_ihl);
    252 
     268        size_t data_offs = sizeof(uint32_t) *
     269            BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h, VI_IHL_l, hdr->ver_ihl);
     270       
    253271        packet->size = tot_len - data_offs;
    254272        packet->data = calloc(packet->size, 1);

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

    redf0d27 r02a09ed  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 
    4544#include "sroute.h"
    4645#include "inetsrv.h"
    4746#include "inet_link.h"
    48 #include "inet_util.h"
    4947
    5048static FIBRIL_MUTEX_INITIALIZE(sroute_list_lock);
    … …  
    9795inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
    9896{
    99         uint32_t addr_addr;
    100         int rc = inet_addr_pack(addr, &addr_addr);
    101         if (rc != EOK)
    102                 return NULL;
     97        uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
    10398       
    10499        inet_sroute_t *best = NULL;
    … …  
    111106                    inet_sroute_t, sroute_list);
    112107               
    113                 uint32_t dest_addr;
    114108                uint8_t dest_bits;
    115                 rc = inet_naddr_pack(&sroute->dest, &dest_addr, &dest_bits);
    116                 if (rc != EOK)
     109                uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
     110                    &dest_bits);
     111               
     112                /* Skip comparison with different address family */
     113                if (addr_af != dest_af)
    117114                        continue;
    118115               
    … …  
    121118                        continue;
    122119               
    123                 uint32_t mask = inet_netmask(dest_bits);
    124                 if ((dest_addr & mask) == (addr_addr & mask)) {
     120                if (inet_naddr_compare_mask(&sroute->dest, addr)) {
    125121                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
    126122                            sroute);
Note: See TracChangeset for help on using the changeset viewer.