Changeset 9749e47 in mainline


Ignore:
Timestamp:
2013-10-04T19:23:43Z (10 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.

Files:
7 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile.common

    r26de91a r9749e47  
    202202        $(USPACE_PATH)/app/nterm/nterm \
    203203        $(USPACE_PATH)/app/ping/ping \
    204         $(USPACE_PATH)/app/ping6/ping6 \
    205204        $(USPACE_PATH)/app/stats/stats \
    206205        $(USPACE_PATH)/app/sysinfo/sysinfo \
  • uspace/Makefile

    r26de91a r9749e47  
    7676        app/nettest3 \
    7777        app/ping \
    78         app/ping6 \
    7978        app/sysinfo \
    8079        app/mkbd \
  • uspace/app/ping/ping.c

    r26de91a r9749e47  
    7676};
    7777
    78 static addr32_t src;
    79 static addr32_t dest;
     78static inet_addr_t src_addr;
     79static inet_addr_t dest_addr;
    8080
    8181static bool repeat_forever = false;
    8282static size_t repeat_count = 1;
    8383
    84 static const char *short_options = "rn:";
     84static const char *short_options = "46rn:";
    8585
    8686static void print_syntax(void)
    8787{
    88         printf("Syntax: %s [-n <count>|-r] <host>\n", NAME);
     88        printf("Syntax: %s [<options>] <host>\n", NAME);
     89        printf("\t-n <count> Repeat the specified number of times\n");
     90        printf("\t-r         Repeat forever\n");
     91        printf("\t-4|-6      Use IPv4 or IPv6 destination host address\n");
    8992}
    9093
     
    107110static int ping_ev_recv(inetping_sdu_t *sdu)
    108111{
    109         inet_addr_t src_addr;
    110         inet_addr_set(sdu->src, &src_addr);
    111        
    112         inet_addr_t dest_addr;
    113         inet_addr_set(sdu->dest, &dest_addr);
    114        
    115112        char *asrc;
    116113        int rc = inet_addr_format(&src_addr, &asrc);
     
    139136        inetping_sdu_t sdu;
    140137       
    141         sdu.src = src;
    142         sdu.dest = dest;
     138        sdu.src = src_addr;
     139        sdu.dest = dest_addr;
    143140        sdu.seq_no = seq_no;
    144141        sdu.data = (void *) "foo";
     
    221218        char *adest = NULL;
    222219        char *sdest = NULL;
     220        ip_ver_t ip_ver = ip_any;
    223221       
    224222        int rc = inetping_init(&ev_ops);
     
    243241                        }
    244242                        break;
     243                case '4':
     244                        ip_ver = ip_v4;
     245                        break;
     246                case '6':
     247                        ip_ver = ip_v6;
     248                        break;
    245249                default:
    246250                        printf("Unknown option passed.\n");
     
    257261       
    258262        /* Parse destination address */
    259         inet_addr_t dest_addr;
    260263        rc = inet_addr_parse(argv[optind], &dest_addr);
    261264        if (rc != EOK) {
    262265                /* Try interpreting as a host name */
    263                 rc = dnsr_name2host(argv[optind], &hinfo, ip_v4);
     266                rc = dnsr_name2host(argv[optind], &hinfo, ip_ver);
    264267                if (rc != EOK) {
    265268                        printf("Error resolving host '%s'.\n", argv[optind]);
     
    270273        }
    271274       
    272         ip_ver_t ver = inet_addr_get(&dest_addr, &dest, NULL);
    273         if (ver != ip_v4) {
    274                 printf("Destination '%s' is not an IPv4 address.\n",
    275                     argv[optind]);
    276                 goto error;
    277         }
    278        
    279275        /* Determine source address */
    280         rc = inetping_get_srcaddr(dest, &src);
     276        rc = inetping_get_srcaddr(&dest_addr, &src_addr);
    281277        if (rc != EOK) {
    282278                printf("Failed determining source address.\n");
    283279                goto error;
    284280        }
    285        
    286         inet_addr_t src_addr;
    287         inet_addr_set(src, &src_addr);
    288281       
    289282        rc = inet_addr_format(&src_addr, &asrc);
  • uspace/lib/c/Makefile

    r26de91a r9749e47  
    100100        generic/inetcfg.c \
    101101        generic/inetping.c \
    102         generic/inetping6.c \
    103102        generic/io/asprintf.c \
    104103        generic/io/input.c \
  • uspace/lib/c/generic/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 *
     
    4950
    5051        assert(inetping_sess == NULL);
    51        
     52
    5253        inetping_ev_ops = ev_ops;
    53        
     54
    5455        rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
    5556            IPC_FLAG_BLOCKING);
    5657        if (rc != EOK)
    5758                return ENOENT;
    58        
     59
    5960        inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
    6061            IPC_FLAG_BLOCKING);
    6162        if (inetping_sess == NULL)
    6263                return ENOENT;
    63        
     64
    6465        async_exch_t *exch = async_exchange_begin(inetping_sess);
    6566
    6667        rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6768        async_exchange_end(exch);
    68        
     69
    6970        if (rc != EOK) {
    7071                async_hangup(inetping_sess);
     
    7273                return rc;
    7374        }
    74        
     75
    7576        return EOK;
    7677}
     
    7980{
    8081        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81        
     82
    8283        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
    84             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    85         sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86        
     84        aid_t req = async_send_1(exch, INETPING_SEND, sdu->seq_no, &answer);
     85
     86        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     87        if (rc != EOK) {
     88                async_exchange_end(exch);
     89                async_forget(req);
     90                return rc;
     91        }
     92
     93        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     94        if (rc != EOK) {
     95                async_exchange_end(exch);
     96                async_forget(req);
     97                return rc;
     98        }
     99
     100        rc = async_data_write_start(exch, sdu->data, sdu->size);
     101
    87102        async_exchange_end(exch);
    88        
    89         if (retval != EOK) {
    90                 async_forget(req);
    91                 return retval;
    92         }
    93        
     103
     104        if (rc != EOK) {
     105                async_forget(req);
     106                return rc;
     107        }
     108
     109        sysarg_t retval;
    94110        async_wait_for(req, &retval);
    95         return retval;
    96 }
    97 
    98 int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
     111
     112        return (int) retval;
     113}
     114
     115int inetping_get_srcaddr(const inet_addr_t *remote, inet_addr_t *local)
    99116{
    100117        async_exch_t *exch = async_exchange_begin(inetping_sess);
    101        
    102         sysarg_t local_addr;
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104             &local_addr);
    105        
     118
     119        ipc_call_t answer;
     120        aid_t req = async_send_0(exch, INETPING_GET_SRCADDR, &answer);
     121
     122        int rc = async_data_write_start(exch, remote, sizeof(*remote));
     123        if (rc != EOK) {
     124                async_exchange_end(exch);
     125                async_forget(req);
     126                return rc;
     127        }
     128
     129        ipc_call_t answer_local;
     130        aid_t req_local = async_data_read(exch, local, sizeof(*local),
     131            &answer_local);
     132
    106133        async_exchange_end(exch);
    107        
    108         if (rc != EOK)
    109                 return rc;
    110        
    111         *local = (uint32_t) local_addr;
    112         return EOK;
    113 }
    114 
    115 static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
     134
     135        sysarg_t retval_local;
     136        async_wait_for(req_local, &retval_local);
     137
     138        if (retval_local != EOK) {
     139                async_forget(req);
     140                return (int) retval_local;
     141        }
     142
     143        sysarg_t retval;
     144        async_wait_for(req, &retval);
     145
     146        return (int) retval;
     147}
     148
     149static void inetping_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
    116150{
    117151        inetping_sdu_t sdu;
    118        
    119         sdu.src = IPC_GET_ARG1(*call);
    120         sdu.dest = IPC_GET_ARG2(*call);
    121         sdu.seq_no = IPC_GET_ARG3(*call);
    122        
    123         int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     152
     153        sdu.seq_no = IPC_GET_ARG1(*icall);
     154
     155        ipc_callid_t callid;
     156        size_t size;
     157        if (!async_data_write_receive(&callid, &size)) {
     158                async_answer_0(callid, EREFUSED);
     159                async_answer_0(iid, EREFUSED);
     160                return;
     161        }
     162
     163        if (size != sizeof(sdu.src)) {
     164                async_answer_0(callid, EINVAL);
     165                async_answer_0(iid, EINVAL);
     166                return;
     167        }
     168
     169        int rc = async_data_write_finalize(callid, &sdu.src, size);
    124170        if (rc != EOK) {
    125171                async_answer_0(callid, rc);
    126                 return;
    127         }
    128        
     172                async_answer_0(iid, rc);
     173                return;
     174        }
     175
     176        if (!async_data_write_receive(&callid, &size)) {
     177                async_answer_0(callid, EREFUSED);
     178                async_answer_0(iid, EREFUSED);
     179                return;
     180        }
     181
     182        if (size != sizeof(sdu.dest)) {
     183                async_answer_0(callid, EINVAL);
     184                async_answer_0(iid, EINVAL);
     185                return;
     186        }
     187
     188        rc = async_data_write_finalize(callid, &sdu.dest, size);
     189        if (rc != EOK) {
     190                async_answer_0(callid, rc);
     191                async_answer_0(iid, rc);
     192                return;
     193        }
     194
     195        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     196        if (rc != EOK) {
     197                async_answer_0(iid, rc);
     198                return;
     199        }
     200
    129201        rc = inetping_ev_ops->recv(&sdu);
    130202        free(sdu.data);
    131         async_answer_0(callid, rc);
     203        async_answer_0(iid, rc);
    132204}
    133205
  • uspace/lib/c/include/inet/inetping.h

    r26de91a r9749e47  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
     
    4646extern int inetping_init(inetping_ev_ops_t *);
    4747extern int inetping_send(inetping_sdu_t *);
    48 extern int inetping_get_srcaddr(uint32_t, uint32_t *);
     48extern int inetping_get_srcaddr(const inet_addr_t *, inet_addr_t *);
    4949
    5050#endif
  • uspace/lib/c/include/ipc/inet.h

    r26de91a r9749e47  
    9292} inetping_request_t;
    9393
    94 /** Events on Inet ping6 port */
    95 typedef enum {
    96         INETPING6_EV_RECV = IPC_FIRST_USER_METHOD
    97 } inetping6_event_t;
    98 
    99 /** Requests on Inet ping6 port */
    100 typedef enum {
    101         INETPING6_SEND = IPC_FIRST_USER_METHOD,
    102         INETPING6_GET_SRCADDR
    103 } inetping6_request_t;
    104 
    10594#endif
    10695
  • uspace/lib/c/include/types/inetping.h

    r26de91a r9749e47  
    3838#define LIBC_TYPES_INETPING_H_
    3939
     40#include <inet/addr.h>
    4041#include <sys/types.h>
    4142
    4243typedef struct {
    43         uint32_t src;
    44         uint32_t dest;
     44        inet_addr_t src;
     45        inet_addr_t dest;
    4546        uint16_t seq_no;
    4647        void *data;
  • 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.