Changeset 4c14b88 in mainline for uspace/srv/net/inetsrv/inetping.c


Ignore:
Timestamp:
2013-12-31T07:57:14Z (11 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1b973dc
Parents:
6297465 (diff), 208b5f5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6297465 r4c14b88  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    4344#include <stdlib.h>
    4445#include <sys/types.h>
    45 #include <net/socket_codes.h>
     46#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         uint16_t family = inet_addr_get(&local_addr, local, NULL);
    74         if (family != AF_INET)
     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}
Note: See TracChangeset for help on using the changeset viewer.