Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9749e47 rfeeac0d  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
    3  * Copyright (c) 2013 Martin Decky
     2 * Copyright (c) 2012 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    4443#include <stdlib.h>
    4544#include <sys/types.h>
    46 #include <types/inetping.h>
     45#include <net/socket_codes.h>
    4746#include "icmp.h"
    48 #include "icmpv6.h"
    4947#include "icmp_std.h"
    5048#include "inetsrv.h"
    … …  
    5957static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    6058{
    61         if (sdu->src.version != sdu->dest.version)
     59        return icmp_ping_send(client->ident, sdu);
     60}
     61
     62static 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        uint16_t family = inet_addr_get(&local_addr, local, NULL);
     74        if (family != AF_INET)
    6275                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);
     76       
     77        return EOK;
    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_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 
     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       
    124110        async_exchange_end(exch);
    125 
     111       
    126112        if (rc != EOK) {
    127113                async_forget(req);
    128114                return rc;
    129115        }
    130 
     116       
    131117        sysarg_t retval;
    132118        async_wait_for(req, &retval);
    133 
     119       
    134120        return (int) retval;
    135121}
    136122
    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 
     123static void inetping_send_srv(inetping_client_t *client, ipc_callid_t callid,
     124    ipc_call_t *call)
     125{
    142126        inetping_sdu_t sdu;
    143127        int rc;
    144128
    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         }
     129        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
    186130
    187131        rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0,
    188132            &sdu.size);
    189133        if (rc != EOK) {
    190                 async_answer_0(iid, rc);
     134                async_answer_0(callid, rc);
    191135                return;
    192136        }
     137
     138        sdu.src = IPC_GET_ARG1(*call);
     139        sdu.dest = IPC_GET_ARG2(*call);
     140        sdu.seq_no = IPC_GET_ARG3(*call);
    193141
    194142        rc = inetping_send(client, &sdu);
    195143        free(sdu.data);
    196144
    197         async_answer_0(iid, rc);
     145        async_answer_0(callid, rc);
    198146}
    199147
    200148static void inetping_get_srcaddr_srv(inetping_client_t *client,
    201     ipc_callid_t iid, ipc_call_t *icall)
     149    ipc_callid_t callid, ipc_call_t *call)
    202150{
    203151        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);
     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);
    253158}
    254159
    … …  
    258163        if (sess == NULL)
    259164                return ENOMEM;
    260 
     165       
    261166        client->sess = sess;
    262167        link_initialize(&client->client_list);
    263 
     168       
    264169        fibril_mutex_lock(&client_list_lock);
    265170        client->ident = ++inetping_ident;
    266171        list_append(&client->client_list, &client_list);
    267172        fibril_mutex_unlock(&client_list_lock);
    268 
     173       
    269174        return EOK;
    270175}
    … …  
    274179        async_hangup(client->sess);
    275180        client->sess = NULL;
    276 
     181       
    277182        fibril_mutex_lock(&client_list_lock);
    278183        list_remove(&client->client_list);
    … …  
    283188{
    284189        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    285 
     190       
    286191        /* Accept the connection */
    287192        async_answer_0(iid, EOK);
    288 
     193       
    289194        inetping_client_t client;
    290195        int rc = inetping_client_init(&client);
    291196        if (rc != EOK)
    292197                return;
    293 
     198       
    294199        while (true) {
    295200                ipc_call_t call;
    296201                ipc_callid_t callid = async_get_call(&call);
    297202                sysarg_t method = IPC_GET_IMETHOD(call);
    298 
     203               
    299204                if (!method) {
    300205                        /* The other side has hung up */
    … …  
    302207                        break;
    303208                }
    304 
     209               
    305210                switch (method) {
    306211                case INETPING_SEND:
    … …  
    314219                }
    315220        }
    316 
     221       
    317222        inetping_client_fini(&client);
    318223}
Note: See TracChangeset for help on using the changeset viewer.