Ignore:
File:
1 edited

Legend:

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

    r3e66428 rf9b2cb4c  
    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         rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
     54
     55        rc = loc_service_get_id(SERVICE_NAME_INET, &inetping_svc,
    5556            IPC_FLAG_BLOCKING);
    5657        if (rc != EOK)
    5758                return ENOENT;
    58        
    59         inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
     59
     60        inetping_sess = loc_service_connect(inetping_svc, INTERFACE_INETPING,
    6061            IPC_FLAG_BLOCKING);
    6162        if (inetping_sess == NULL)
    6263                return ENOENT;
     64
     65        async_exch_t *exch = async_exchange_begin(inetping_sess);
     66
     67        port_id_t port;
     68        rc = async_create_callback_port(exch, INTERFACE_INETPING_CB, 0, 0,
     69            inetping_cb_conn, NULL, &port);
    6370       
    64         async_exch_t *exch = async_exchange_begin(inetping_sess);
    65 
    66         rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6771        async_exchange_end(exch);
    68        
     72
    6973        if (rc != EOK) {
    7074                async_hangup(inetping_sess);
     
    7276                return rc;
    7377        }
    74        
     78
    7579        return EOK;
    7680}
     
    7983{
    8084        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81        
     85
    8286        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        
     87        aid_t req = async_send_1(exch, INETPING_SEND, sdu->seq_no, &answer);
     88
     89        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     90        if (rc != EOK) {
     91                async_exchange_end(exch);
     92                async_forget(req);
     93                return rc;
     94        }
     95
     96        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     97        if (rc != EOK) {
     98                async_exchange_end(exch);
     99                async_forget(req);
     100                return rc;
     101        }
     102
     103        rc = async_data_write_start(exch, sdu->data, sdu->size);
     104
    87105        async_exchange_end(exch);
    88        
    89         if (retval != EOK) {
    90                 async_forget(req);
    91                 return retval;
    92         }
    93        
     106
     107        if (rc != EOK) {
     108                async_forget(req);
     109                return rc;
     110        }
     111
     112        sysarg_t retval;
    94113        async_wait_for(req, &retval);
    95         return retval;
    96 }
    97 
    98 int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
     114
     115        return (int) retval;
     116}
     117
     118int inetping_get_srcaddr(const inet_addr_t *remote, inet_addr_t *local)
    99119{
    100120        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        
     121
     122        ipc_call_t answer;
     123        aid_t req = async_send_0(exch, INETPING_GET_SRCADDR, &answer);
     124
     125        int rc = async_data_write_start(exch, remote, sizeof(*remote));
     126        if (rc != EOK) {
     127                async_exchange_end(exch);
     128                async_forget(req);
     129                return rc;
     130        }
     131
     132        ipc_call_t answer_local;
     133        aid_t req_local = async_data_read(exch, local, sizeof(*local),
     134            &answer_local);
     135
    106136        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)
     137
     138        sysarg_t retval_local;
     139        async_wait_for(req_local, &retval_local);
     140
     141        if (retval_local != EOK) {
     142                async_forget(req);
     143                return (int) retval_local;
     144        }
     145
     146        sysarg_t retval;
     147        async_wait_for(req, &retval);
     148
     149        return (int) retval;
     150}
     151
     152static void inetping_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
    116153{
    117154        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);
     155
     156        sdu.seq_no = IPC_GET_ARG1(*icall);
     157
     158        ipc_callid_t callid;
     159        size_t size;
     160        if (!async_data_write_receive(&callid, &size)) {
     161                async_answer_0(callid, EREFUSED);
     162                async_answer_0(iid, EREFUSED);
     163                return;
     164        }
     165
     166        if (size != sizeof(sdu.src)) {
     167                async_answer_0(callid, EINVAL);
     168                async_answer_0(iid, EINVAL);
     169                return;
     170        }
     171
     172        int rc = async_data_write_finalize(callid, &sdu.src, size);
    124173        if (rc != EOK) {
    125174                async_answer_0(callid, rc);
    126                 return;
    127         }
    128        
     175                async_answer_0(iid, rc);
     176                return;
     177        }
     178
     179        if (!async_data_write_receive(&callid, &size)) {
     180                async_answer_0(callid, EREFUSED);
     181                async_answer_0(iid, EREFUSED);
     182                return;
     183        }
     184
     185        if (size != sizeof(sdu.dest)) {
     186                async_answer_0(callid, EINVAL);
     187                async_answer_0(iid, EINVAL);
     188                return;
     189        }
     190
     191        rc = async_data_write_finalize(callid, &sdu.dest, size);
     192        if (rc != EOK) {
     193                async_answer_0(callid, rc);
     194                async_answer_0(iid, rc);
     195                return;
     196        }
     197
     198        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     199        if (rc != EOK) {
     200                async_answer_0(iid, rc);
     201                return;
     202        }
     203
    129204        rc = inetping_ev_ops->recv(&sdu);
    130205        free(sdu.data);
    131         async_answer_0(callid, rc);
     206        async_answer_0(iid, rc);
    132207}
    133208
Note: See TracChangeset for help on using the changeset viewer.