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


Ignore:
Timestamp:
2013-12-25T13:05:25Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
bc54126c
Parents:
f4a47e52 (diff), 6946f23 (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:

merge mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rf4a47e52 r0773396  
    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        
    84         list_foreach(client_list, link) {
    85                 inetping_client_t *client = list_get_instance(link,
    86                     inetping_client_t, client_list);
    87                
     83
     84        list_foreach(client_list, client_list, inetping_client_t, client) {
    8885                if (client->ident == ident) {
    8986                        fibril_mutex_unlock(&client_list_lock);
    … …  
    9188                }
    9289        }
    93        
     90
    9491        fibril_mutex_unlock(&client_list_lock);
    9592        return NULL;
    … …  
    103100                return ENOENT;
    104101        }
    105        
     102
    106103        async_exch_t *exch = async_exchange_begin(client->sess);
    107        
     104
    108105        ipc_call_t answer;
    109         aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
    110             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    111         int rc = async_data_write_start(exch, sdu->data, sdu->size);
    112        
    113         async_exchange_end(exch);
    114        
    115         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);
    116111                async_forget(req);
    117112                return rc;
    118113        }
    119        
     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
    120131        sysarg_t retval;
    121132        async_wait_for(req, &retval);
    122        
     133
    123134        return (int) retval;
    124135}
    125136
    126 static void inetping_send_srv(inetping_client_t *client, ipc_callid_t callid,
    127     ipc_call_t *call)
    128 {
     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
    129142        inetping_sdu_t sdu;
    130143        int rc;
    131144
    132         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        }
    133186
    134187        rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0,
    135188            &sdu.size);
    136189        if (rc != EOK) {
    137                 async_answer_0(callid, rc);
    138                 return;
    139         }
    140 
    141         sdu.src = IPC_GET_ARG1(*call);
    142         sdu.dest = IPC_GET_ARG2(*call);
    143         sdu.seq_no = IPC_GET_ARG3(*call);
     190                async_answer_0(iid, rc);
     191                return;
     192        }
    144193
    145194        rc = inetping_send(client, &sdu);
    146195        free(sdu.data);
    147196
    148         async_answer_0(callid, rc);
     197        async_answer_0(iid, rc);
    149198}
    150199
    151200static void inetping_get_srcaddr_srv(inetping_client_t *client,
    152     ipc_callid_t callid, ipc_call_t *call)
     201    ipc_callid_t iid, ipc_call_t *icall)
    153202{
    154203        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    155        
    156         uint32_t remote = IPC_GET_ARG1(*call);
    157         uint32_t local = 0;
    158        
    159         int rc = inetping_get_srcaddr(client, remote, &local);
    160         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);
    161253}
    162254
    … …  
    166258        if (sess == NULL)
    167259                return ENOMEM;
    168        
     260
    169261        client->sess = sess;
    170262        link_initialize(&client->client_list);
    171        
     263
    172264        fibril_mutex_lock(&client_list_lock);
    173265        client->ident = ++inetping_ident;
    174266        list_append(&client->client_list, &client_list);
    175267        fibril_mutex_unlock(&client_list_lock);
    176        
     268
    177269        return EOK;
    178270}
    … …  
    182274        async_hangup(client->sess);
    183275        client->sess = NULL;
    184        
     276
    185277        fibril_mutex_lock(&client_list_lock);
    186278        list_remove(&client->client_list);
    … …  
    191283{
    192284        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    193        
     285
    194286        /* Accept the connection */
    195287        async_answer_0(iid, EOK);
    196        
     288
    197289        inetping_client_t client;
    198290        int rc = inetping_client_init(&client);
    199291        if (rc != EOK)
    200292                return;
    201        
     293
    202294        while (true) {
    203295                ipc_call_t call;
    204296                ipc_callid_t callid = async_get_call(&call);
    205297                sysarg_t method = IPC_GET_IMETHOD(call);
    206                
     298
    207299                if (!method) {
    208300                        /* The other side has hung up */
    … …  
    210302                        break;
    211303                }
    212                
     304
    213305                switch (method) {
    214306                case INETPING_SEND:
    … …  
    222314                }
    223315        }
    224        
     316
    225317        inetping_client_fini(&client);
    226318}
Note: See TracChangeset for help on using the changeset viewer.