Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9749e47 r13be2583  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
    3  * Copyright (c) 2013 Martin Decky
     2 * Copyright (c) 2012 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    4544#include <sys/types.h>
    4645#include <types/inetping.h>
     46#include <net/socket_codes.h>
    4747#include "icmp.h"
    48 #include "icmpv6.h"
    4948#include "icmp_std.h"
    5049#include "inetsrv.h"
    … …  
    5958static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    6059{
    61         if (sdu->src.version != sdu->dest.version)
     60        return icmp_ping_send(client->ident, sdu);
     61}
     62
     63static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
     64    addr32_t *local)
     65{
     66        inet_addr_t remote_addr;
     67        inet_addr_set(remote, &remote_addr);
     68       
     69        inet_addr_t local_addr;
     70        int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
     71        if (rc != EOK)
     72                return rc;
     73       
     74        uint16_t family = inet_addr_get(&local_addr, local, NULL);
     75        if (family != AF_INET)
    6276                return EINVAL;
    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 
    74 static 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);
     77       
     78        return EOK;
    7879}
    7980
    … …  
    8182{
    8283        fibril_mutex_lock(&client_list_lock);
    83 
     84       
    8485        list_foreach(client_list, client_list, inetping_client_t, client) {
    8586                if (client->ident == ident) {
    … …  
    8889                }
    8990        }
    90 
     91       
    9192        fibril_mutex_unlock(&client_list_lock);
    9293        return NULL;
    … …  
    100101                return ENOENT;
    101102        }
    102 
     103       
    103104        async_exch_t *exch = async_exchange_begin(client->sess);
    104 
     105       
    105106        ipc_call_t answer;
    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);
    111                 async_forget(req);
    112                 return rc;
    113         }
    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 
     107        aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
     108            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
     109        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     110       
    124111        async_exchange_end(exch);
    125 
     112       
    126113        if (rc != EOK) {
    127114                async_forget(req);
    128115                return rc;
    129116        }
    130 
     117       
    131118        sysarg_t retval;
    132119        async_wait_for(req, &retval);
    133 
     120       
    134121        return (int) retval;
    135122}
    136123
    137 static 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 
     124static void inetping_send_srv(inetping_client_t *client, ipc_callid_t callid,
     125    ipc_call_t *call)
     126{
    142127        inetping_sdu_t sdu;
    143128        int rc;
    144129
    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         }
     130        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
    186131
    187132        rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0,
    188133            &sdu.size);
    189134        if (rc != EOK) {
    190                 async_answer_0(iid, rc);
     135                async_answer_0(callid, rc);
    191136                return;
    192137        }
     138
     139        sdu.src = IPC_GET_ARG1(*call);
     140        sdu.dest = IPC_GET_ARG2(*call);
     141        sdu.seq_no = IPC_GET_ARG3(*call);
    193142
    194143        rc = inetping_send(client, &sdu);
    195144        free(sdu.data);
    196145
    197         async_answer_0(iid, rc);
     146        async_answer_0(callid, rc);
    198147}
    199148
    200149static void inetping_get_srcaddr_srv(inetping_client_t *client,
    201     ipc_callid_t iid, ipc_call_t *icall)
     150    ipc_callid_t callid, ipc_call_t *call)
    202151{
    203152        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    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);
     153       
     154        uint32_t remote = IPC_GET_ARG1(*call);
     155        uint32_t local = 0;
     156       
     157        int rc = inetping_get_srcaddr(client, remote, &local);
     158        async_answer_1(callid, rc, (sysarg_t) local);
    253159}
    254160
    … …  
    258164        if (sess == NULL)
    259165                return ENOMEM;
    260 
     166       
    261167        client->sess = sess;
    262168        link_initialize(&client->client_list);
    263 
     169       
    264170        fibril_mutex_lock(&client_list_lock);
    265171        client->ident = ++inetping_ident;
    266172        list_append(&client->client_list, &client_list);
    267173        fibril_mutex_unlock(&client_list_lock);
    268 
     174       
    269175        return EOK;
    270176}
    … …  
    274180        async_hangup(client->sess);
    275181        client->sess = NULL;
    276 
     182       
    277183        fibril_mutex_lock(&client_list_lock);
    278184        list_remove(&client->client_list);
    … …  
    283189{
    284190        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    285 
     191       
    286192        /* Accept the connection */
    287193        async_answer_0(iid, EOK);
    288 
     194       
    289195        inetping_client_t client;
    290196        int rc = inetping_client_init(&client);
    291197        if (rc != EOK)
    292198                return;
    293 
     199       
    294200        while (true) {
    295201                ipc_call_t call;
    296202                ipc_callid_t callid = async_get_call(&call);
    297203                sysarg_t method = IPC_GET_IMETHOD(call);
    298 
     204               
    299205                if (!method) {
    300206                        /* The other side has hung up */
    … …  
    302208                        break;
    303209                }
    304 
     210               
    305211                switch (method) {
    306212                case INETPING_SEND:
    … …  
    314220                }
    315221        }
    316 
     222       
    317223        inetping_client_fini(&client);
    318224}
Note: See TracChangeset for help on using the changeset viewer.