Changeset 9749e47 in mainline for uspace/srv/net


Ignore:
Timestamp:
2013-10-04T19:23:43Z (12 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1d04b2
Parents:
26de91a
Message:

ping6 - resistance is futile.

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

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/inetsrv/Makefile

    r26de91a r9749e47  
    3838        inetcfg.c \
    3939        inetping.c \
    40         inetping6.c \
    4140        ndp.c \
    4241        ntrans.c \

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

    r26de91a r9749e47  
    130130        inetping_sdu_t sdu;
    131131
    132         ip_ver_t ver = inet_addr_get(&dgram->src, &sdu.src, NULL);
    133         if (ver != ip_v4)
    134                 return EINVAL;
    135 
    136         ver = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
    137         if (ver != ip_v4)
    138                 return EINVAL;
    139 
     132        sdu.src = dgram->src;
     133        sdu.dest = dgram->dest;
    140134        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    141135        sdu.data = reply + sizeof(icmp_echo_t);
    … …  
    169163        inet_dgram_t dgram;
    170164
    171         inet_addr_set(sdu->src, &dgram.src);
    172         inet_addr_set(sdu->dest, &dgram.dest);
    173 
     165        dgram.src = sdu->src;
     166        dgram.dest = sdu->dest;
    174167        dgram.iplink = 0;
    175168        dgram.tos = ICMP_TOS;

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

    r26de91a r9749e47  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 #include <types/inetping6.h>
     42#include <types/inetping.h>
    4343#include "icmpv6.h"
    4444#include "icmpv6_std.h"
    4545#include "inetsrv.h"
    46 #include "inetping6.h"
     46#include "inetping.h"
    4747#include "pdu.h"
    4848
    … …  
    116116                return EINVAL;
    117117       
    118         inetping6_sdu_t sdu;
    119        
    120         ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &sdu.src);
    121         ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &sdu.dest);
    122        
    123         if ((src_ver != dest_ver) || (src_ver != ip_v6))
    124                 return EINVAL;
     118        inetping_sdu_t sdu;
     119       
     120        sdu.src = dgram->src;
     121        sdu.dest = dgram->dest;
    125122       
    126123        icmpv6_message_t *reply = (icmpv6_message_t *) dgram->data;
    … …  
    132129        uint16_t ident = uint16_t_be2host(reply->un.echo.ident);
    133130       
    134         return inetping6_recv(ident, &sdu);
     131        return inetping_recv(ident, &sdu);
    135132}
    136133
    … …  
    160157}
    161158
    162 int icmpv6_ping_send(uint16_t ident, inetping6_sdu_t *sdu)
     159int icmpv6_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    163160{
    164161        size_t rsize = sizeof(icmpv6_message_t) + sdu->size;
    … …  
    179176        inet_dgram_t dgram;
    180177       
    181         inet_addr_set6(sdu->src, &dgram.src);
    182         inet_addr_set6(sdu->dest, &dgram.dest);
     178        dgram.src = sdu->src;
     179        dgram.dest = sdu->dest;
    183180        dgram.iplink = 0;
    184181        dgram.tos = 0;
    … …  
    188185        icmpv6_phdr_t phdr;
    189186       
    190         host2addr128_t_be(sdu->src, phdr.src_addr);
    191         host2addr128_t_be(sdu->dest, phdr.dest_addr);
     187        assert(sdu->src.version == ip_v6);
     188        assert(sdu->dest.version == ip_v6);
     189       
     190        host2addr128_t_be(sdu->src.addr6, phdr.src_addr);
     191        host2addr128_t_be(sdu->dest.addr6, phdr.dest_addr);
    192192        phdr.length = host2uint32_t_be(dgram.size);
    193193        memset(phdr.zeroes, 0, 3);

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

    r26de91a r9749e47  
    3838#define ICMPV6_H_
    3939
    40 #include <types/inetping6.h>
     40#include <types/inetping.h>
    4141#include "inetsrv.h"
    4242
    4343extern int icmpv6_recv(inet_dgram_t *);
    44 extern int icmpv6_ping_send(uint16_t, inetping6_sdu_t *);
     44extern int icmpv6_ping_send(uint16_t, inetping_sdu_t *);
    4545
    4646#endif

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

    r26de91a r9749e47  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    4546#include <types/inetping.h>
    4647#include "icmp.h"
     48#include "icmpv6.h"
    4749#include "icmp_std.h"
    4850#include "inetsrv.h"
    … …  
    5759static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    5860{
    59         return icmp_ping_send(client->ident, sdu);
    60 }
    61 
    62 static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
    63     addr32_t *local)
    64 {
    65         inet_addr_t remote_addr;
    66         inet_addr_set(remote, &remote_addr);
    67        
    68         inet_addr_t local_addr;
    69         int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
    70         if (rc != EOK)
    71                 return rc;
    72        
    73         ip_ver_t ver = inet_addr_get(&local_addr, local, NULL);
    74         if (ver != ip_v4)
     61        if (sdu->src.version != sdu->dest.version)
    7562                return EINVAL;
    76        
    77         return EOK;
     63
     64        switch (sdu->src.version) {
     65        case ip_v4:
     66                return icmp_ping_send(client->ident, sdu);
     67        case ip_v6:
     68                return icmpv6_ping_send(client->ident, sdu);
     69        default:
     70                return EINVAL;
     71        }
     72}
     73
     74static int inetping_get_srcaddr(inetping_client_t *client,
     75    inet_addr_t *remote, inet_addr_t *local)
     76{
     77        return inet_get_srcaddr(remote, ICMP_TOS, local);
    7878}
    7979
    … …  
    8181{
    8282        fibril_mutex_lock(&client_list_lock);
    83        
     83
    8484        list_foreach(client_list, client_list, inetping_client_t, client) {
    8585                if (client->ident == ident) {
    … …  
    8888                }
    8989        }
    90        
     90
    9191        fibril_mutex_unlock(&client_list_lock);
    9292        return NULL;
    … …  
    100100                return ENOENT;
    101101        }
    102        
     102
    103103        async_exch_t *exch = async_exchange_begin(client->sess);
    104        
     104
    105105        ipc_call_t answer;
    106         aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
    107             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    108         int rc = async_data_write_start(exch, sdu->data, sdu->size);
    109        
    110         async_exchange_end(exch);
    111        
    112         if (rc != EOK) {
     106        aid_t req = async_send_1(exch, INETPING_EV_RECV, sdu->seq_no, &answer);
     107
     108        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     109        if (rc != EOK) {
     110                async_exchange_end(exch);
    113111                async_forget(req);
    114112                return rc;
    115113        }
    116        
     114
     115        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     116        if (rc != EOK) {
     117                async_exchange_end(exch);
     118                async_forget(req);
     119                return rc;
     120        }
     121
     122        rc = async_data_write_start(exch, sdu->data, sdu->size);
     123
     124        async_exchange_end(exch);
     125
     126        if (rc != EOK) {
     127                async_forget(req);
     128                return rc;
     129        }
     130
    117131        sysarg_t retval;
    118132        async_wait_for(req, &retval);
    119        
     133
    120134        return (int) retval;
    121135}
    122136
    123 static void inetping_send_srv(inetping_client_t *client, ipc_callid_t callid,
    124     ipc_call_t *call)
    125 {
     137static void inetping_send_srv(inetping_client_t *client, ipc_callid_t iid,
     138    ipc_call_t *icall)
     139{
     140        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
     141
    126142        inetping_sdu_t sdu;
    127143        int rc;
    128144
    129         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
     145        sdu.seq_no = IPC_GET_ARG1(*icall);
     146
     147        ipc_callid_t callid;
     148        size_t size;
     149        if (!async_data_write_receive(&callid, &size)) {
     150                async_answer_0(callid, EREFUSED);
     151                async_answer_0(iid, EREFUSED);
     152                return;
     153        }
     154
     155        if (size != sizeof(sdu.src)) {
     156                async_answer_0(callid, EINVAL);
     157                async_answer_0(iid, EINVAL);
     158                return;
     159        }
     160
     161        rc = async_data_write_finalize(callid, &sdu.src, size);
     162        if (rc != EOK) {
     163                async_answer_0(callid, rc);
     164                async_answer_0(iid, rc);
     165                return;
     166        }
     167
     168        if (!async_data_write_receive(&callid, &size)) {
     169                async_answer_0(callid, EREFUSED);
     170                async_answer_0(iid, EREFUSED);
     171                return;
     172        }
     173
     174        if (size != sizeof(sdu.dest)) {
     175                async_answer_0(callid, EINVAL);
     176                async_answer_0(iid, EINVAL);
     177                return;
     178        }
     179
     180        rc = async_data_write_finalize(callid, &sdu.dest, size);
     181        if (rc != EOK) {
     182                async_answer_0(callid, rc);
     183                async_answer_0(iid, rc);
     184                return;
     185        }
    130186
    131187        rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0,
    132188            &sdu.size);
    133189        if (rc != EOK) {
    134                 async_answer_0(callid, rc);
    135                 return;
    136         }
    137 
    138         sdu.src = IPC_GET_ARG1(*call);
    139         sdu.dest = IPC_GET_ARG2(*call);
    140         sdu.seq_no = IPC_GET_ARG3(*call);
     190                async_answer_0(iid, rc);
     191                return;
     192        }
    141193
    142194        rc = inetping_send(client, &sdu);
    143195        free(sdu.data);
    144196
    145         async_answer_0(callid, rc);
     197        async_answer_0(iid, rc);
    146198}
    147199
    148200static void inetping_get_srcaddr_srv(inetping_client_t *client,
    149     ipc_callid_t callid, ipc_call_t *call)
     201    ipc_callid_t iid, ipc_call_t *icall)
    150202{
    151203        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    152        
    153         uint32_t remote = IPC_GET_ARG1(*call);
    154         uint32_t local = 0;
    155        
    156         int rc = inetping_get_srcaddr(client, remote, &local);
    157         async_answer_1(callid, rc, (sysarg_t) local);
     204
     205        ipc_callid_t callid;
     206        size_t size;
     207
     208        inet_addr_t local;
     209        inet_addr_t remote;
     210
     211        if (!async_data_write_receive(&callid, &size)) {
     212                async_answer_0(callid, EREFUSED);
     213                async_answer_0(iid, EREFUSED);
     214                return;
     215        }
     216
     217        if (size != sizeof(remote)) {
     218                async_answer_0(callid, EINVAL);
     219                async_answer_0(iid, EINVAL);
     220                return;
     221        }
     222
     223        int rc = async_data_write_finalize(callid, &remote, size);
     224        if (rc != EOK) {
     225                async_answer_0(callid, rc);
     226                async_answer_0(iid, rc);
     227                return;
     228        }
     229
     230        rc = inetping_get_srcaddr(client, &remote, &local);
     231        if (rc != EOK) {
     232                async_answer_0(iid, rc);
     233                return;
     234        }
     235
     236        if (!async_data_read_receive(&callid, &size)) {
     237                async_answer_0(callid, EREFUSED);
     238                async_answer_0(iid, EREFUSED);
     239                return;
     240        }
     241
     242        if (size != sizeof(local)) {
     243                async_answer_0(callid, EINVAL);
     244                async_answer_0(iid, EINVAL);
     245                return;
     246        }
     247
     248        rc = async_data_read_finalize(callid, &local, size);
     249        if (rc != EOK)
     250                async_answer_0(callid, rc);
     251
     252        async_answer_0(iid, rc);
    158253}
    159254
    … …  
    163258        if (sess == NULL)
    164259                return ENOMEM;
    165        
     260
    166261        client->sess = sess;
    167262        link_initialize(&client->client_list);
    168        
     263
    169264        fibril_mutex_lock(&client_list_lock);
    170265        client->ident = ++inetping_ident;
    171266        list_append(&client->client_list, &client_list);
    172267        fibril_mutex_unlock(&client_list_lock);
    173        
     268
    174269        return EOK;
    175270}
    … …  
    179274        async_hangup(client->sess);
    180275        client->sess = NULL;
    181        
     276
    182277        fibril_mutex_lock(&client_list_lock);
    183278        list_remove(&client->client_list);
    … …  
    188283{
    189284        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    190        
     285
    191286        /* Accept the connection */
    192287        async_answer_0(iid, EOK);
    193        
     288
    194289        inetping_client_t client;
    195290        int rc = inetping_client_init(&client);
    196291        if (rc != EOK)
    197292                return;
    198        
     293
    199294        while (true) {
    200295                ipc_call_t call;
    201296                ipc_callid_t callid = async_get_call(&call);
    202297                sysarg_t method = IPC_GET_IMETHOD(call);
    203                
     298
    204299                if (!method) {
    205300                        /* The other side has hung up */
    … …  
    207302                        break;
    208303                }
    209                
     304
    210305                switch (method) {
    211306                case INETPING_SEND:
    … …  
    219314                }
    220315        }
    221        
     316
    222317        inetping_client_fini(&client);
    223318}

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

    r26de91a r9749e47  
    5454#include "inetcfg.h"
    5555#include "inetping.h"
    56 #include "inetping6.h"
    5756#include "inet_link.h"
    5857#include "reass.h"
    … …  
    111110        rc = loc_service_register_with_iface(SERVICE_NAME_INETPING, &sid,
    112111            INET_PORT_PING);
    113         if (rc != EOK) {
    114                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    115                 return EEXIST;
    116         }
    117        
    118         rc = loc_service_register_with_iface(SERVICE_NAME_INETPING6, &sid,
    119             INET_PORT_PING6);
    120112        if (rc != EOK) {
    121113                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    … …  
    452444                inetping_conn(iid, icall, arg);
    453445                break;
    454         case INET_PORT_PING6:
    455                 inetping6_conn(iid, icall, arg);
    456                 break;
    457446        default:
    458447                async_answer_0(iid, ENOTSUP);
Note: See TracChangeset for help on using the changeset viewer.