Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/inetping.c

    r9749e47 r3e66428  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
    3  * Copyright (c) 2013 Martin Decky
     2 * Copyright (c) 2012 Jiri Svoboda
    43 * All rights reserved.
    54 *
     
    5049
    5150        assert(inetping_sess == NULL);
    52 
     51       
    5352        inetping_ev_ops = ev_ops;
    54 
     53       
    5554        rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
    5655            IPC_FLAG_BLOCKING);
    5756        if (rc != EOK)
    5857                return ENOENT;
    59 
     58       
    6059        inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
    6160            IPC_FLAG_BLOCKING);
    6261        if (inetping_sess == NULL)
    6362                return ENOENT;
    64 
     63       
    6564        async_exch_t *exch = async_exchange_begin(inetping_sess);
    6665
    6766        rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6867        async_exchange_end(exch);
    69 
     68       
    7069        if (rc != EOK) {
    7170                async_hangup(inetping_sess);
     
    7372                return rc;
    7473        }
    75 
     74       
    7675        return EOK;
    7776}
     
    8079{
    8180        async_exch_t *exch = async_exchange_begin(inetping_sess);
    82 
     81       
    8382        ipc_call_t answer;
    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);
     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       
     87        async_exchange_end(exch);
     88       
     89        if (retval != EOK) {
    8990                async_forget(req);
    90                 return rc;
     91                return retval;
    9192        }
    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 
    102         async_exchange_end(exch);
    103 
    104         if (rc != EOK) {
    105                 async_forget(req);
    106                 return rc;
    107         }
    108 
    109         sysarg_t retval;
     93       
    11094        async_wait_for(req, &retval);
    111 
    112         return (int) retval;
     95        return retval;
    11396}
    11497
    115 int inetping_get_srcaddr(const inet_addr_t *remote, inet_addr_t *local)
     98int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
    11699{
    117100        async_exch_t *exch = async_exchange_begin(inetping_sess);
    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);
     101       
     102        sysarg_t local_addr;
     103        int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
     104            &local_addr);
     105       
     106        async_exchange_end(exch);
     107       
     108        if (rc != EOK)
    126109                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 
    133         async_exchange_end(exch);
    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;
     110       
     111        *local = (uint32_t) local_addr;
     112        return EOK;
    147113}
    148114
    149 static void inetping_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
     115static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
    150116{
    151117        inetping_sdu_t sdu;
    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);
     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);
     124        if (rc != EOK) {
     125                async_answer_0(callid, rc);
    160126                return;
    161127        }
    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);
    170         if (rc != EOK) {
    171                 async_answer_0(callid, rc);
    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 
     128       
    201129        rc = inetping_ev_ops->recv(&sdu);
    202130        free(sdu.data);
    203         async_answer_0(iid, rc);
     131        async_answer_0(callid, rc);
    204132}
    205133
Note: See TracChangeset for help on using the changeset viewer.