Changeset 984a9ba in mainline for uspace/srv/net


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

Location:
uspace/srv/net
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/dhcp/main.c

    r76f566d r984a9ba  
    5050#define NAME  "dhcp"
    5151
    52 static void dhcp_client_conn(cap_call_handle_t, ipc_call_t *, void *);
     52static void dhcp_client_conn(ipc_call_t *, void *);
    5353
    5454static errno_t dhcp_init(void)
    … …  
    8484}
    8585
    86 static void dhcp_link_add_srv(cap_call_handle_t chandle, ipc_call_t *call)
     86static void dhcp_link_add_srv(ipc_call_t *call)
    8787{
    8888        sysarg_t link_id;
    … …  
    9494
    9595        rc = dhcpsrv_link_add(link_id);
    96         async_answer_0(chandle, rc);
     96        async_answer_0(call, rc);
    9797}
    9898
    99 static void dhcp_link_remove_srv(cap_call_handle_t chandle, ipc_call_t *call)
     99static void dhcp_link_remove_srv(ipc_call_t *call)
    100100{
    101101        sysarg_t link_id;
    … …  
    107107
    108108        rc = dhcpsrv_link_remove(link_id);
    109         async_answer_0(chandle, rc);
     109        async_answer_0(call, rc);
    110110}
    111111
    112 static void dhcp_discover_srv(cap_call_handle_t chandle, ipc_call_t *call)
     112static void dhcp_discover_srv(ipc_call_t *call)
    113113{
    114114        sysarg_t link_id;
    … …  
    120120
    121121        rc = dhcpsrv_discover(link_id);
    122         async_answer_0(chandle, rc);
     122        async_answer_0(call, rc);
    123123}
    124124
    125 static void dhcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     125static void dhcp_client_conn(ipc_call_t *icall, void *arg)
    126126{
    127127        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_client_conn()");
    128128
    129129        /* Accept the connection */
    130         async_answer_0(icall_handle, EOK);
     130        async_answer_0(icall, EOK);
    131131
    132132        while (true) {
    133133                ipc_call_t call;
    134                 cap_call_handle_t chandle = async_get_call(&call);
     134                async_get_call(&call);
    135135                sysarg_t method = IPC_GET_IMETHOD(call);
    136136
    137137                if (!method) {
    138138                        /* The other side has hung up */
    139                         async_answer_0(chandle, EOK);
     139                        async_answer_0(&call, EOK);
    140140                        return;
    141141                }
    … …  
    143143                switch (method) {
    144144                case DHCP_LINK_ADD:
    145                         dhcp_link_add_srv(chandle, &call);
     145                        dhcp_link_add_srv(&call);
    146146                        break;
    147147                case DHCP_LINK_REMOVE:
    148                         dhcp_link_remove_srv(chandle, &call);
     148                        dhcp_link_remove_srv(&call);
    149149                        break;
    150150                case DHCP_DISCOVER:
    151                         dhcp_discover_srv(chandle, &call);
     151                        dhcp_discover_srv(&call);
    152152                        break;
    153153                default:
    154                         async_answer_0(chandle, EINVAL);
     154                        async_answer_0(&call, EINVAL);
    155155                }
    156156        }

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    r76f566d r984a9ba  
    5353#define NAME  "dnsres"
    5454
    55 static void dnsr_client_conn(cap_call_handle_t, ipc_call_t *, void *);
     55static void dnsr_client_conn(ipc_call_t *, void *);
    5656
    5757static errno_t dnsr_init(void)
    … …  
    8686}
    8787
    88 static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    89     ipc_call_t *icall)
     88static void dnsr_name2host_srv(dnsr_client_t *client, ipc_call_t *icall)
    9089{
    9190        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    … …  
    9796            DNS_NAME_MAX_SIZE, 0, NULL);
    9897        if (rc != EOK) {
    99                 async_answer_0(icall_handle, rc);
     98                async_answer_0(icall, rc);
    10099                return;
    101100        }
    … …  
    104103        rc = dns_name2host(name, &hinfo, ver);
    105104        if (rc != EOK) {
    106                 async_answer_0(icall_handle, rc);
    107                 return;
    108         }
    109 
    110         cap_call_handle_t chandle;
     105                async_answer_0(icall, rc);
     106                return;
     107        }
     108
     109        ipc_call_t call;
    111110        size_t size;
    112         if (!async_data_read_receive(&chandle, &size)) {
    113                 async_answer_0(chandle, EREFUSED);
    114                 async_answer_0(icall_handle, EREFUSED);
     111        if (!async_data_read_receive(&call, &size)) {
     112                async_answer_0(&call, EREFUSED);
     113                async_answer_0(icall, EREFUSED);
    115114                return;
    116115        }
    117116
    118117        if (size != sizeof(inet_addr_t)) {
    119                 async_answer_0(chandle, EINVAL);
    120                 async_answer_0(icall_handle, EINVAL);
    121                 return;
    122         }
    123 
    124         rc = async_data_read_finalize(chandle, &hinfo->addr, size);
    125         if (rc != EOK) {
    126                 async_answer_0(chandle, rc);
    127                 async_answer_0(icall_handle, rc);
    128                 return;
    129         }
    130 
    131         if (!async_data_read_receive(&chandle, &size)) {
    132                 async_answer_0(chandle, EREFUSED);
    133                 async_answer_0(icall_handle, EREFUSED);
     118                async_answer_0(&call, EINVAL);
     119                async_answer_0(icall, EINVAL);
     120                return;
     121        }
     122
     123        rc = async_data_read_finalize(&call, &hinfo->addr, size);
     124        if (rc != EOK) {
     125                async_answer_0(&call, rc);
     126                async_answer_0(icall, rc);
     127                return;
     128        }
     129
     130        if (!async_data_read_receive(&call, &size)) {
     131                async_answer_0(&call, EREFUSED);
     132                async_answer_0(icall, EREFUSED);
    134133                return;
    135134        }
    … …  
    137136        size_t act_size = str_size(hinfo->cname);
    138137        if (act_size > size) {
    139                 async_answer_0(chandle, EINVAL);
    140                 async_answer_0(icall_handle, EINVAL);
    141                 return;
    142         }
    143 
    144         rc = async_data_read_finalize(chandle, hinfo->cname, act_size);
     138                async_answer_0(&call, EINVAL);
     139                async_answer_0(icall, EINVAL);
     140                return;
     141        }
     142
     143        rc = async_data_read_finalize(&call, hinfo->cname, act_size);
    145144        if (rc != EOK)
    146                 async_answer_0(chandle, rc);
    147 
    148         async_answer_0(icall_handle, rc);
     145                async_answer_0(&call, rc);
     146
     147        async_answer_0(icall, rc);
    149148
    150149        dns_hostinfo_destroy(hinfo);
    151150}
    152151
    153 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    154     ipc_call_t *icall)
     152static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_call_t *icall)
    155153{
    156154        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    157155
    158         cap_call_handle_t chandle;
     156        ipc_call_t call;
    159157        size_t size;
    160         if (!async_data_read_receive(&chandle, &size)) {
    161                 async_answer_0(chandle, EREFUSED);
    162                 async_answer_0(icall_handle, EREFUSED);
     158        if (!async_data_read_receive(&call, &size)) {
     159                async_answer_0(&call, EREFUSED);
     160                async_answer_0(icall, EREFUSED);
    163161                return;
    164162        }
    165163
    166164        if (size != sizeof(inet_addr_t)) {
    167                 async_answer_0(chandle, EINVAL);
    168                 async_answer_0(icall_handle, EINVAL);
     165                async_answer_0(&call, EINVAL);
     166                async_answer_0(icall, EINVAL);
    169167                return;
    170168        }
    … …  
    172170        // FIXME locking
    173171
    174         errno_t rc = async_data_read_finalize(chandle, &dns_server_addr, size);
     172        errno_t rc = async_data_read_finalize(&call, &dns_server_addr, size);
    175173        if (rc != EOK)
    176                 async_answer_0(chandle, rc);
    177 
    178         async_answer_0(icall_handle, rc);
    179 }
    180 
    181 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    182     ipc_call_t *icall)
     174                async_answer_0(&call, rc);
     175
     176        async_answer_0(icall, rc);
     177}
     178
     179static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_call_t *icall)
    183180{
    184181        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    185182
    186         cap_call_handle_t chandle;
     183        ipc_call_t call;
    187184        size_t size;
    188         if (!async_data_write_receive(&chandle, &size)) {
    189                 async_answer_0(chandle, EREFUSED);
    190                 async_answer_0(icall_handle, EREFUSED);
     185        if (!async_data_write_receive(&call, &size)) {
     186                async_answer_0(&call, EREFUSED);
     187                async_answer_0(icall, EREFUSED);
    191188                return;
    192189        }
    193190
    194191        if (size != sizeof(inet_addr_t)) {
    195                 async_answer_0(chandle, EINVAL);
    196                 async_answer_0(icall_handle, EINVAL);
     192                async_answer_0(&call, EINVAL);
     193                async_answer_0(icall, EINVAL);
    197194                return;
    198195        }
    … …  
    200197        // FIXME locking
    201198
    202         errno_t rc = async_data_write_finalize(chandle, &dns_server_addr, size);
    203         if (rc != EOK) {
    204                 async_answer_0(chandle, rc);
    205                 async_answer_0(icall_handle, rc);
    206         }
    207 
    208         async_answer_0(icall_handle, rc);
    209 }
    210 
    211 static void dnsr_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     199        errno_t rc = async_data_write_finalize(&call, &dns_server_addr, size);
     200        if (rc != EOK) {
     201                async_answer_0(&call, rc);
     202                async_answer_0(icall, rc);
     203        }
     204
     205        async_answer_0(icall, rc);
     206}
     207
     208static void dnsr_client_conn(ipc_call_t *icall, void *arg)
    212209{
    213210        dnsr_client_t client;
    … …  
    216213
    217214        /* Accept the connection */
    218         async_answer_0(icall_handle, EOK);
     215        async_answer_0(icall, EOK);
    219216
    220217        while (true) {
    221218                ipc_call_t call;
    222                 cap_call_handle_t chandle = async_get_call(&call);
     219                async_get_call(&call);
    223220                sysarg_t method = IPC_GET_IMETHOD(call);
    224221
    225222                if (!method) {
    226223                        /* The other side has hung up */
    227                         async_answer_0(chandle, EOK);
     224                        async_answer_0(&call, EOK);
    228225                        return;
    229226                }
    … …  
    231228                switch (method) {
    232229                case DNSR_NAME2HOST:
    233                         dnsr_name2host_srv(&client, chandle, &call);
     230                        dnsr_name2host_srv(&client, &call);
    234231                        break;
    235232                case DNSR_GET_SRVADDR:
    236                         dnsr_get_srvaddr_srv(&client, chandle, &call);
     233                        dnsr_get_srvaddr_srv(&client, &call);
    237234                        break;
    238235                case DNSR_SET_SRVADDR:
    239                         dnsr_set_srvaddr_srv(&client, chandle, &call);
     236                        dnsr_set_srvaddr_srv(&client, &call);
    240237                        break;
    241238                default:
    242                         async_answer_0(chandle, EINVAL);
     239                        async_answer_0(&call, EINVAL);
    243240                }
    244241        }

  • uspace/srv/net/ethip/ethip.c

    r76f566d r984a9ba  
    6363static errno_t ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    6464
    65 static void ethip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     65static void ethip_client_conn(ipc_call_t *icall, void *arg);
    6666
    6767static iplink_ops_t ethip_iplink_ops = {
    … …  
    142142}
    143143
    144 static void ethip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     144static void ethip_client_conn(ipc_call_t *icall, void *arg)
    145145{
    146146        ethip_nic_t *nic;
    … …  
    155155        }
    156156
    157         iplink_conn(icall_handle, icall, &nic->iplink);
     157        iplink_conn(icall, &nic->iplink);
    158158}
    159159

  • uspace/srv/net/ethip/ethip_nic.c

    r76f566d r984a9ba  
    5252
    5353static errno_t ethip_nic_open(service_id_t sid);
    54 static void ethip_nic_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     54static void ethip_nic_cb_conn(ipc_call_t *icall, void *arg);
    5555
    5656static LIST_INITIALIZE(ethip_nic_list);
    … …  
    229229}
    230230
    231 static void ethip_nic_addr_changed(ethip_nic_t *nic, cap_call_handle_t chandle,
    232     ipc_call_t *call)
     231static void ethip_nic_addr_changed(ethip_nic_t *nic, ipc_call_t *call)
    233232{
    234233        uint8_t *addr;
    … …  
    236235        errno_t rc;
    237236
    238         rc = async_data_write_accept((void **)&addr, false, 0, 0, 0, &size);
     237        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &size);
    239238        if (rc != EOK) {
    240239                log_msg(LOG_DEFAULT, LVL_DEBUG, "data_write_accept() failed");
    … …  
    255254
    256255        free(addr);
    257         async_answer_0(chandle, EOK);
    258 }
    259 
    260 static void ethip_nic_received(ethip_nic_t *nic, cap_call_handle_t chandle,
    261     ipc_call_t *call)
     256        async_answer_0(call, EOK);
     257}
     258
     259static void ethip_nic_received(ethip_nic_t *nic, ipc_call_t *call)
    262260{
    263261        errno_t rc;
    … …  
    282280
    283281        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() done, rc=%s", str_error_name(rc));
    284         async_answer_0(chandle, rc);
    285 }
    286 
    287 static void ethip_nic_device_state(ethip_nic_t *nic, cap_call_handle_t chandle,
    288     ipc_call_t *call)
     282        async_answer_0(call, rc);
     283}
     284
     285static void ethip_nic_device_state(ethip_nic_t *nic, ipc_call_t *call)
    289286{
    290287        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_device_state()");
    291         async_answer_0(chandle, ENOTSUP);
    292 }
    293 
    294 static void ethip_nic_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     288        async_answer_0(call, ENOTSUP);
     289}
     290
     291static void ethip_nic_cb_conn(ipc_call_t *icall, void *arg)
    295292{
    296293        ethip_nic_t *nic = (ethip_nic_t *)arg;
    … …  
    300297        while (true) {
    301298                ipc_call_t call;
    302                 cap_call_handle_t chandle = async_get_call(&call);
     299                async_get_call(&call);
    303300
    304301                if (!IPC_GET_IMETHOD(call)) {
    … …  
    309306                switch (IPC_GET_IMETHOD(call)) {
    310307                case NIC_EV_ADDR_CHANGED:
    311                         ethip_nic_addr_changed(nic, chandle, &call);
     308                        ethip_nic_addr_changed(nic, &call);
    312309                        break;
    313310                case NIC_EV_RECEIVED:
    314                         ethip_nic_received(nic, chandle, &call);
     311                        ethip_nic_received(nic, &call);
    315312                        break;
    316313                case NIC_EV_DEVICE_STATE:
    317                         ethip_nic_device_state(nic, chandle, &call);
     314                        ethip_nic_device_state(nic, &call);
    318315                        break;
    319316                default:
    320317                        log_msg(LOG_DEFAULT, LVL_DEBUG, "unknown IPC method: %" PRIun, IPC_GET_IMETHOD(call));
    321                         async_answer_0(chandle, ENOTSUP);
     318                        async_answer_0(&call, ENOTSUP);
    322319                }
    323320        }

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

    r76f566d r984a9ba  
    253253}
    254254
    255 static void inetcfg_addr_create_static_srv(cap_call_handle_t icall_handle,
    256     ipc_call_t *icall)
     255static void inetcfg_addr_create_static_srv(ipc_call_t *icall)
    257256{
    258257        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
    … …  
    260259        sysarg_t link_id = IPC_GET_ARG1(*icall);
    261260
    262         cap_call_handle_t chandle;
     261        ipc_call_t call;
    263262        size_t size;
    264         if (!async_data_write_receive(&chandle, &size)) {
    265                 async_answer_0(chandle, EINVAL);
    266                 async_answer_0(icall_handle, EINVAL);
     263        if (!async_data_write_receive(&call, &size)) {
     264                async_answer_0(&call, EINVAL);
     265                async_answer_0(icall, EINVAL);
    267266                return;
    268267        }
    269268
    270269        if (size != sizeof(inet_naddr_t)) {
    271                 async_answer_0(chandle, EINVAL);
    272                 async_answer_0(icall_handle, EINVAL);
     270                async_answer_0(&call, EINVAL);
     271                async_answer_0(icall, EINVAL);
    273272                return;
    274273        }
    275274
    276275        inet_naddr_t naddr;
    277         errno_t rc = async_data_write_finalize(chandle, &naddr, size);
    278         if (rc != EOK) {
    279                 async_answer_0(chandle, rc);
    280                 async_answer_0(icall_handle, rc);
     276        errno_t rc = async_data_write_finalize(&call, &naddr, size);
     277        if (rc != EOK) {
     278                async_answer_0(&call, rc);
     279                async_answer_0(icall, rc);
    281280                return;
    282281        }
    … …  
    286285            0, NULL);
    287286        if (rc != EOK) {
    288                 async_answer_0(icall_handle, rc);
     287                async_answer_0(icall, rc);
    289288                return;
    290289        }
    … …  
    293292        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    294293        free(name);
    295         async_answer_1(icall_handle, rc, addr_id);
    296 }
    297 
    298 static void inetcfg_addr_delete_srv(cap_call_handle_t chandle, ipc_call_t *call)
     294        async_answer_1(icall, rc, addr_id);
     295}
     296
     297static void inetcfg_addr_delete_srv(ipc_call_t *call)
    299298{
    300299        sysarg_t addr_id;
    … …  
    306305
    307306        rc = inetcfg_addr_delete(addr_id);
    308         async_answer_0(chandle, rc);
    309 }
    310 
    311 static void inetcfg_addr_get_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     307        async_answer_0(call, rc);
     308}
     309
     310static void inetcfg_addr_get_srv(ipc_call_t *icall)
    312311{
    313312        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    … …  
    323322        errno_t rc = inetcfg_addr_get(addr_id, &ainfo);
    324323        if (rc != EOK) {
    325                 async_answer_0(icall_handle, rc);
    326                 return;
    327         }
    328 
    329         cap_call_handle_t chandle;
     324                async_answer_0(icall, rc);
     325                return;
     326        }
     327
     328        ipc_call_t call;
    330329        size_t size;
    331         if (!async_data_read_receive(&chandle, &size)) {
    332                 async_answer_0(chandle, EREFUSED);
    333                 async_answer_0(icall_handle, EREFUSED);
     330        if (!async_data_read_receive(&call, &size)) {
     331                async_answer_0(&call, EREFUSED);
     332                async_answer_0(icall, EREFUSED);
    334333                return;
    335334        }
    336335
    337336        if (size != sizeof(inet_naddr_t)) {
    338                 async_answer_0(chandle, EINVAL);
    339                 async_answer_0(icall_handle, EINVAL);
    340                 return;
    341         }
    342 
    343         rc = async_data_read_finalize(chandle, &ainfo.naddr, size);
    344         if (rc != EOK) {
    345                 async_answer_0(chandle, rc);
    346                 async_answer_0(icall_handle, rc);
    347                 return;
    348         }
    349 
    350         if (!async_data_read_receive(&chandle, &size)) {
    351                 async_answer_0(chandle, EREFUSED);
    352                 async_answer_0(icall_handle, EREFUSED);
    353                 return;
    354         }
    355 
    356         rc = async_data_read_finalize(chandle, ainfo.name,
     337                async_answer_0(&call, EINVAL);
     338                async_answer_0(icall, EINVAL);
     339                return;
     340        }
     341
     342        rc = async_data_read_finalize(&call, &ainfo.naddr, size);
     343        if (rc != EOK) {
     344                async_answer_0(&call, rc);
     345                async_answer_0(icall, rc);
     346                return;
     347        }
     348
     349        if (!async_data_read_receive(&call, &size)) {
     350                async_answer_0(&call, EREFUSED);
     351                async_answer_0(icall, EREFUSED);
     352                return;
     353        }
     354
     355        rc = async_data_read_finalize(&call, ainfo.name,
    357356            min(size, str_size(ainfo.name)));
    358357        free(ainfo.name);
    359358
    360359        if (rc != EOK) {
    361                 async_answer_0(chandle, rc);
    362                 async_answer_0(icall_handle, rc);
    363                 return;
    364         }
    365 
    366         async_answer_1(icall_handle, rc, ainfo.ilink);
    367 }
    368 
    369 static void inetcfg_addr_get_id_srv(cap_call_handle_t chandle, ipc_call_t *call)
     360                async_answer_0(&call, rc);
     361                async_answer_0(icall, rc);
     362                return;
     363        }
     364
     365        async_answer_1(icall, rc, ainfo.ilink);
     366}
     367
     368static void inetcfg_addr_get_id_srv(ipc_call_t *call)
    370369{
    371370        char *name;
    … …  
    381380            0, NULL);
    382381        if (rc != EOK) {
    383                 async_answer_0(chandle, rc);
     382                async_answer_0(call, rc);
    384383                return;
    385384        }
    … …  
    388387        rc = inetcfg_addr_get_id(name, link_id, &addr_id);
    389388        free(name);
    390         async_answer_1(chandle, rc, addr_id);
    391 }
    392 
    393 static void inetcfg_get_addr_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
    394 {
    395         cap_call_handle_t rcall_handle;
     389        async_answer_1(call, rc, addr_id);
     390}
     391
     392static void inetcfg_get_addr_list_srv(ipc_call_t *call)
     393{
     394        ipc_call_t rcall;
    396395        size_t count;
    397396        size_t max_size;
    … …  
    403402        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    404403
    405         if (!async_data_read_receive(&rcall_handle, &max_size)) {
    406                 async_answer_0(rcall_handle, EREFUSED);
    407                 async_answer_0(chandle, EREFUSED);
     404        if (!async_data_read_receive(&rcall, &max_size)) {
     405                async_answer_0(&rcall, EREFUSED);
     406                async_answer_0(call, EREFUSED);
    408407                return;
    409408        }
    … …  
    411410        rc = inetcfg_get_addr_list(&id_buf, &count);
    412411        if (rc != EOK) {
    413                 async_answer_0(rcall_handle, rc);
    414                 async_answer_0(chandle, rc);
     412                async_answer_0(&rcall, rc);
     413                async_answer_0(call, rc);
    415414                return;
    416415        }
    … …  
    419418        size = min(act_size, max_size);
    420419
    421         errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
     420        errno_t retval = async_data_read_finalize(&rcall, id_buf, size);
    422421        free(id_buf);
    423422
    424         async_answer_1(chandle, retval, act_size);
    425 }
    426 
    427 static void inetcfg_get_link_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
    428 {
    429         cap_call_handle_t rcall_handle;
     423        async_answer_1(call, retval, act_size);
     424}
     425
     426static void inetcfg_get_link_list_srv(ipc_call_t *call)
     427{
     428        ipc_call_t rcall;
    430429        size_t count;
    431430        size_t max_size;
    … …  
    437436        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    438437
    439         if (!async_data_read_receive(&rcall_handle, &max_size)) {
    440                 async_answer_0(rcall_handle, EREFUSED);
    441                 async_answer_0(chandle, EREFUSED);
     438        if (!async_data_read_receive(&rcall, &max_size)) {
     439                async_answer_0(&rcall, EREFUSED);
     440                async_answer_0(call, EREFUSED);
    442441                return;
    443442        }
    … …  
    445444        rc = inetcfg_get_link_list(&id_buf, &count);
    446445        if (rc != EOK) {
    447                 async_answer_0(rcall_handle, rc);
    448                 async_answer_0(chandle, rc);
     446                async_answer_0(&rcall, rc);
     447                async_answer_0(call, rc);
    449448                return;
    450449        }
    … …  
    453452        size = min(act_size, max_size);
    454453
    455         errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
     454        errno_t retval = async_data_read_finalize(&rcall, id_buf, size);
    456455        free(id_buf);
    457456
    458         async_answer_1(chandle, retval, act_size);
    459 }
    460 
    461 static void inetcfg_get_sroute_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
    462 {
    463         cap_call_handle_t rcall_handle;
     457        async_answer_1(call, retval, act_size);
     458}
     459
     460static void inetcfg_get_sroute_list_srv(ipc_call_t *call)
     461{
     462        ipc_call_t rcall;
    464463        size_t count;
    465464        size_t max_size;
    … …  
    471470        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
    472471
    473         if (!async_data_read_receive(&rcall_handle, &max_size)) {
    474                 async_answer_0(rcall_handle, EREFUSED);
    475                 async_answer_0(chandle, EREFUSED);
     472        if (!async_data_read_receive(&rcall, &max_size)) {
     473                async_answer_0(&rcall, EREFUSED);
     474                async_answer_0(call, EREFUSED);
    476475                return;
    477476        }
    … …  
    479478        rc = inetcfg_get_sroute_list(&id_buf, &count);
    480479        if (rc != EOK) {
    481                 async_answer_0(rcall_handle, rc);
    482                 async_answer_0(chandle, rc);
     480                async_answer_0(&rcall, rc);
     481                async_answer_0(call, rc);
    483482                return;
    484483        }
    … …  
    487486        size = min(act_size, max_size);
    488487
    489         errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
     488        errno_t retval = async_data_read_finalize(&rcall, id_buf, size);
    490489        free(id_buf);
    491490
    492         async_answer_1(chandle, retval, act_size);
    493 }
    494 
    495 static void inetcfg_link_add_srv(cap_call_handle_t chandle, ipc_call_t *call)
     491        async_answer_1(call, retval, act_size);
     492}
     493
     494static void inetcfg_link_add_srv(ipc_call_t *call)
    496495{
    497496        sysarg_t link_id;
    … …  
    503502
    504503        rc = inetcfg_link_add(link_id);
    505         async_answer_0(chandle, rc);
    506 }
    507 
    508 static void inetcfg_link_get_srv(cap_call_handle_t chandle, ipc_call_t *call)
    509 {
    510         cap_call_handle_t name_chandle;
    511         cap_call_handle_t laddr_chandle;
     504        async_answer_0(call, rc);
     505}
     506
     507static void inetcfg_link_get_srv(ipc_call_t *call)
     508{
     509        ipc_call_t name;
     510        ipc_call_t laddr;
    512511        size_t name_max_size;
    513512        size_t laddr_max_size;
    … …  
    522521        linfo.name = NULL;
    523522
    524         if (!async_data_read_receive(&name_chandle, &name_max_size)) {
    525                 async_answer_0(name_chandle, EREFUSED);
    526                 async_answer_0(chandle, EREFUSED);
    527                 return;
    528         }
    529 
    530         if (!async_data_read_receive(&laddr_chandle, &laddr_max_size)) {
    531                 async_answer_0(name_chandle, EREFUSED);
    532                 async_answer_0(chandle, EREFUSED);
     523        if (!async_data_read_receive(&name, &name_max_size)) {
     524                async_answer_0(&name, EREFUSED);
     525                async_answer_0(call, EREFUSED);
     526                return;
     527        }
     528
     529        if (!async_data_read_receive(&laddr, &laddr_max_size)) {
     530                async_answer_0(&laddr, EREFUSED);
     531                async_answer_0(&name, EREFUSED);
     532                async_answer_0(call, EREFUSED);
    533533                return;
    534534        }
    … …  
    536536        rc = inetcfg_link_get(link_id, &linfo);
    537537        if (rc != EOK) {
    538                 async_answer_0(laddr_chandle, rc);
    539                 async_answer_0(name_chandle, rc);
    540                 async_answer_0(chandle, rc);
    541                 return;
    542         }
    543 
    544         errno_t retval = async_data_read_finalize(name_chandle, linfo.name,
     538                async_answer_0(&laddr, rc);
     539                async_answer_0(&name, rc);
     540                async_answer_0(call, rc);
     541                return;
     542        }
     543
     544        errno_t retval = async_data_read_finalize(&name, linfo.name,
    545545            min(name_max_size, str_size(linfo.name)));
    546546        if (retval != EOK) {
    547547                free(linfo.name);
    548                 async_answer_0(laddr_chandle, retval);
    549                 async_answer_0(chandle, retval);
    550                 return;
    551         }
    552 
    553         retval = async_data_read_finalize(laddr_chandle, &linfo.mac_addr,
     548                async_answer_0(&laddr, retval);
     549                async_answer_0(call, retval);
     550                return;
     551        }
     552
     553        retval = async_data_read_finalize(&laddr, &linfo.mac_addr,
    554554            min(laddr_max_size, sizeof(linfo.mac_addr)));
    555555
    556556        free(linfo.name);
    557557
    558         async_answer_1(chandle, retval, linfo.def_mtu);
    559 }
    560 
    561 static void inetcfg_link_remove_srv(cap_call_handle_t chandle, ipc_call_t *call)
     558        async_answer_1(call, retval, linfo.def_mtu);
     559}
     560
     561static void inetcfg_link_remove_srv(ipc_call_t *call)
    562562{
    563563        sysarg_t link_id;
    … …  
    569569
    570570        rc = inetcfg_link_remove(link_id);
    571         async_answer_0(chandle, rc);
    572 }
    573 
    574 static void inetcfg_sroute_create_srv(cap_call_handle_t icall_handle,
    575     ipc_call_t *icall)
     571        async_answer_0(call, rc);
     572}
     573
     574static void inetcfg_sroute_create_srv(ipc_call_t *icall)
    576575{
    577576        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
    578577
    579         cap_call_handle_t chandle;
     578        ipc_call_t call;
    580579        size_t size;
    581         if (!async_data_write_receive(&chandle, &size)) {
    582                 async_answer_0(chandle, EINVAL);
    583                 async_answer_0(icall_handle, EINVAL);
     580        if (!async_data_write_receive(&call, &size)) {
     581                async_answer_0(&call, EINVAL);
     582                async_answer_0(icall, EINVAL);
    584583                return;
    585584        }
    586585
    587586        if (size != sizeof(inet_naddr_t)) {
    588                 async_answer_0(chandle, EINVAL);
    589                 async_answer_0(icall_handle, EINVAL);
     587                async_answer_0(&call, EINVAL);
     588                async_answer_0(icall, EINVAL);
    590589                return;
    591590        }
    592591
    593592        inet_naddr_t dest;
    594         errno_t rc = async_data_write_finalize(chandle, &dest, size);
    595         if (rc != EOK) {
    596                 async_answer_0(chandle, rc);
    597                 async_answer_0(icall_handle, rc);
    598                 return;
    599         }
    600 
    601         if (!async_data_write_receive(&chandle, &size)) {
    602                 async_answer_0(chandle, EINVAL);
    603                 async_answer_0(icall_handle, EINVAL);
     593        errno_t rc = async_data_write_finalize(&call, &dest, size);
     594        if (rc != EOK) {
     595                async_answer_0(&call, rc);
     596                async_answer_0(icall, rc);
     597                return;
     598        }
     599
     600        if (!async_data_write_receive(&call, &size)) {
     601                async_answer_0(&call, EINVAL);
     602                async_answer_0(icall, EINVAL);
    604603                return;
    605604        }
    606605
    607606        if (size != sizeof(inet_addr_t)) {
    608                 async_answer_0(chandle, EINVAL);
    609                 async_answer_0(icall_handle, EINVAL);
     607                async_answer_0(&call, EINVAL);
     608                async_answer_0(icall, EINVAL);
    610609                return;
    611610        }
    612611
    613612        inet_addr_t router;
    614         rc = async_data_write_finalize(chandle, &router, size);
    615         if (rc != EOK) {
    616                 async_answer_0(chandle, rc);
    617                 async_answer_0(icall_handle, rc);
     613        rc = async_data_write_finalize(&call, &router, size);
     614        if (rc != EOK) {
     615                async_answer_0(&call, rc);
     616                async_answer_0(icall, rc);
    618617                return;
    619618        }
    … …  
    623622            0, NULL);
    624623        if (rc != EOK) {
    625                 async_answer_0(icall_handle, rc);
     624                async_answer_0(icall, rc);
    626625                return;
    627626        }
    … …  
    630629        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    631630        free(name);
    632         async_answer_1(icall_handle, rc, sroute_id);
    633 }
    634 
    635 static void inetcfg_sroute_delete_srv(cap_call_handle_t chandle, ipc_call_t *call)
     631        async_answer_1(icall, rc, sroute_id);
     632}
     633
     634static void inetcfg_sroute_delete_srv(ipc_call_t *call)
    636635{
    637636        sysarg_t sroute_id;
    … …  
    643642
    644643        rc = inetcfg_sroute_delete(sroute_id);
    645         async_answer_0(chandle, rc);
    646 }
    647 
    648 static void inetcfg_sroute_get_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     644        async_answer_0(call, rc);
     645}
     646
     647static void inetcfg_sroute_get_srv(ipc_call_t *icall)
    649648{
    650649        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    … …  
    660659        errno_t rc = inetcfg_sroute_get(sroute_id, &srinfo);
    661660        if (rc != EOK) {
    662                 async_answer_0(icall_handle, rc);
    663                 return;
    664         }
    665 
    666         cap_call_handle_t chandle;
     661                async_answer_0(icall, rc);
     662                return;
     663        }
     664
     665        ipc_call_t call;
    667666        size_t size;
    668         if (!async_data_read_receive(&chandle, &size)) {
    669                 async_answer_0(chandle, EREFUSED);
    670                 async_answer_0(icall_handle, EREFUSED);
     667        if (!async_data_read_receive(&call, &size)) {
     668                async_answer_0(&call, EREFUSED);
     669                async_answer_0(icall, EREFUSED);
    671670                return;
    672671        }
    673672
    674673        if (size != sizeof(inet_naddr_t)) {
    675                 async_answer_0(chandle, EINVAL);
    676                 async_answer_0(icall_handle, EINVAL);
    677                 return;
    678         }
    679 
    680         rc = async_data_read_finalize(chandle, &srinfo.dest, size);
    681         if (rc != EOK) {
    682                 async_answer_0(chandle, rc);
    683                 async_answer_0(icall_handle, rc);
    684                 return;
    685         }
    686 
    687         if (!async_data_read_receive(&chandle, &size)) {
    688                 async_answer_0(chandle, EREFUSED);
    689                 async_answer_0(icall_handle, EREFUSED);
     674                async_answer_0(&call, EINVAL);
     675                async_answer_0(icall, EINVAL);
     676                return;
     677        }
     678
     679        rc = async_data_read_finalize(&call, &srinfo.dest, size);
     680        if (rc != EOK) {
     681                async_answer_0(&call, rc);
     682                async_answer_0(icall, rc);
     683                return;
     684        }
     685
     686        if (!async_data_read_receive(&call, &size)) {
     687                async_answer_0(&call, EREFUSED);
     688                async_answer_0(icall, EREFUSED);
    690689                return;
    691690        }
    692691
    693692        if (size != sizeof(inet_addr_t)) {
    694                 async_answer_0(chandle, EINVAL);
    695                 async_answer_0(icall_handle, EINVAL);
    696                 return;
    697         }
    698 
    699         rc = async_data_read_finalize(chandle, &srinfo.router, size);
    700         if (rc != EOK) {
    701                 async_answer_0(chandle, rc);
    702                 async_answer_0(icall_handle, rc);
    703                 return;
    704         }
    705 
    706         if (!async_data_read_receive(&chandle, &size)) {
    707                 async_answer_0(chandle, EREFUSED);
    708                 async_answer_0(icall_handle, EREFUSED);
    709                 return;
    710         }
    711 
    712         rc = async_data_read_finalize(chandle, srinfo.name,
     693                async_answer_0(&call, EINVAL);
     694                async_answer_0(icall, EINVAL);
     695                return;
     696        }
     697
     698        rc = async_data_read_finalize(&call, &srinfo.router, size);
     699        if (rc != EOK) {
     700                async_answer_0(&call, rc);
     701                async_answer_0(icall, rc);
     702                return;
     703        }
     704
     705        if (!async_data_read_receive(&call, &size)) {
     706                async_answer_0(&call, EREFUSED);
     707                async_answer_0(icall, EREFUSED);
     708                return;
     709        }
     710
     711        rc = async_data_read_finalize(&call, srinfo.name,
    713712            min(size, str_size(srinfo.name)));
    714713        free(srinfo.name);
    715714
    716         async_answer_0(icall_handle, rc);
    717 }
    718 
    719 static void inetcfg_sroute_get_id_srv(cap_call_handle_t chandle, ipc_call_t *call)
     715        async_answer_0(icall, rc);
     716}
     717
     718static void inetcfg_sroute_get_id_srv(ipc_call_t *call)
    720719{
    721720        char *name;
    … …  
    728727            0, NULL);
    729728        if (rc != EOK) {
    730                 async_answer_0(chandle, rc);
     729                async_answer_0(call, rc);
    731730                return;
    732731        }
    … …  
    735734        rc = inetcfg_sroute_get_id(name, &sroute_id);
    736735        free(name);
    737         async_answer_1(chandle, rc, sroute_id);
    738 }
    739 
    740 void inet_cfg_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     736        async_answer_1(call, rc, sroute_id);
     737}
     738
     739void inet_cfg_conn(ipc_call_t *icall, void *arg)
    741740{
    742741        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_cfg_conn()");
    743742
    744743        /* Accept the connection */
    745         async_answer_0(icall_handle, EOK);
     744        async_answer_0(icall, EOK);
    746745
    747746        while (true) {
    748747                ipc_call_t call;
    749                 cap_call_handle_t chandle = async_get_call(&call);
     748                async_get_call(&call);
    750749                sysarg_t method = IPC_GET_IMETHOD(call);
    751750
    … …  
    753752                if (!method) {
    754753                        /* The other side has hung up */
    755                         async_answer_0(chandle, EOK);
     754                        async_answer_0(&call, EOK);
    756755                        return;
    757756                }
    … …  
    759758                switch (method) {
    760759                case INETCFG_ADDR_CREATE_STATIC:
    761                         inetcfg_addr_create_static_srv(chandle, &call);
     760                        inetcfg_addr_create_static_srv(&call);
    762761                        break;
    763762                case INETCFG_ADDR_DELETE:
    764                         inetcfg_addr_delete_srv(chandle, &call);
     763                        inetcfg_addr_delete_srv(&call);
    765764                        break;
    766765                case INETCFG_ADDR_GET:
    767                         inetcfg_addr_get_srv(chandle, &call);
     766                        inetcfg_addr_get_srv(&call);
    768767                        break;
    769768                case INETCFG_ADDR_GET_ID:
    770                         inetcfg_addr_get_id_srv(chandle, &call);
     769                        inetcfg_addr_get_id_srv(&call);
    771770                        break;
    772771                case INETCFG_GET_ADDR_LIST:
    773                         inetcfg_get_addr_list_srv(chandle, &call);
     772                        inetcfg_get_addr_list_srv(&call);
    774773                        break;
    775774                case INETCFG_GET_LINK_LIST:
    776                         inetcfg_get_link_list_srv(chandle, &call);
     775                        inetcfg_get_link_list_srv(&call);
    777776                        break;
    778777                case INETCFG_GET_SROUTE_LIST:
    779                         inetcfg_get_sroute_list_srv(chandle, &call);
     778                        inetcfg_get_sroute_list_srv(&call);
    780779                        break;
    781780                case INETCFG_LINK_ADD:
    782                         inetcfg_link_add_srv(chandle, &call);
     781                        inetcfg_link_add_srv(&call);
    783782                        break;
    784783                case INETCFG_LINK_GET:
    785                         inetcfg_link_get_srv(chandle, &call);
     784                        inetcfg_link_get_srv(&call);
    786785                        break;
    787786                case INETCFG_LINK_REMOVE:
    788                         inetcfg_link_remove_srv(chandle, &call);
     787                        inetcfg_link_remove_srv(&call);
    789788                        break;
    790789                case INETCFG_SROUTE_CREATE:
    791                         inetcfg_sroute_create_srv(chandle, &call);
     790                        inetcfg_sroute_create_srv(&call);
    792791                        break;
    793792                case INETCFG_SROUTE_DELETE:
    794                         inetcfg_sroute_delete_srv(chandle, &call);
     793                        inetcfg_sroute_delete_srv(&call);
    795794                        break;
    796795                case INETCFG_SROUTE_GET:
    797                         inetcfg_sroute_get_srv(chandle, &call);
     796                        inetcfg_sroute_get_srv(&call);
    798797                        break;
    799798                case INETCFG_SROUTE_GET_ID:
    800                         inetcfg_sroute_get_id_srv(chandle, &call);
     799                        inetcfg_sroute_get_id_srv(&call);
    801800                        break;
    802801                default:
    803                         async_answer_0(chandle, EINVAL);
     802                        async_answer_0(&call, EINVAL);
    804803                }
    805804        }

  • uspace/srv/net/inetsrv/inetcfg.h

    r76f566d r984a9ba  
    3838#define INETCFG_H_
    3939
    40 extern void inet_cfg_conn(cap_call_handle_t, ipc_call_t *, void *);
     40extern void inet_cfg_conn(ipc_call_t *, void *);
    4141
    4242#endif

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

    r76f566d r984a9ba  
    136136}
    137137
    138 static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t icall_handle,
    139     ipc_call_t *icall)
     138static void inetping_send_srv(inetping_client_t *client, ipc_call_t *icall)
    140139{
    141140        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
    … …  
    146145        sdu.seq_no = IPC_GET_ARG1(*icall);
    147146
    148         cap_call_handle_t chandle;
     147        ipc_call_t call;
    149148        size_t size;
    150         if (!async_data_write_receive(&chandle, &size)) {
    151                 async_answer_0(chandle, EREFUSED);
    152                 async_answer_0(icall_handle, EREFUSED);
     149        if (!async_data_write_receive(&call, &size)) {
     150                async_answer_0(&call, EREFUSED);
     151                async_answer_0(icall, EREFUSED);
    153152                return;
    154153        }
    155154
    156155        if (size != sizeof(sdu.src)) {
    157                 async_answer_0(chandle, EINVAL);
    158                 async_answer_0(icall_handle, EINVAL);
    159                 return;
    160         }
    161 
    162         rc = async_data_write_finalize(chandle, &sdu.src, size);
    163         if (rc != EOK) {
    164                 async_answer_0(chandle, rc);
    165                 async_answer_0(icall_handle, rc);
    166                 return;
    167         }
    168 
    169         if (!async_data_write_receive(&chandle, &size)) {
    170                 async_answer_0(chandle, EREFUSED);
    171                 async_answer_0(icall_handle, EREFUSED);
     156                async_answer_0(&call, EINVAL);
     157                async_answer_0(icall, EINVAL);
     158                return;
     159        }
     160
     161        rc = async_data_write_finalize(&call, &sdu.src, size);
     162        if (rc != EOK) {
     163                async_answer_0(&call, rc);
     164                async_answer_0(icall, rc);
     165                return;
     166        }
     167
     168        if (!async_data_write_receive(&call, &size)) {
     169                async_answer_0(&call, EREFUSED);
     170                async_answer_0(icall, EREFUSED);
    172171                return;
    173172        }
    174173
    175174        if (size != sizeof(sdu.dest)) {
    176                 async_answer_0(chandle, EINVAL);
    177                 async_answer_0(icall_handle, EINVAL);
    178                 return;
    179         }
    180 
    181         rc = async_data_write_finalize(chandle, &sdu.dest, size);
    182         if (rc != EOK) {
    183                 async_answer_0(chandle, rc);
    184                 async_answer_0(icall_handle, rc);
     175                async_answer_0(&call, EINVAL);
     176                async_answer_0(icall, EINVAL);
     177                return;
     178        }
     179
     180        rc = async_data_write_finalize(&call, &sdu.dest, size);
     181        if (rc != EOK) {
     182                async_answer_0(&call, rc);
     183                async_answer_0(icall, rc);
    185184                return;
    186185        }
    … …  
    189188            &sdu.size);
    190189        if (rc != EOK) {
    191                 async_answer_0(icall_handle, rc);
     190                async_answer_0(icall, rc);
    192191                return;
    193192        }
    … …  
    196195        free(sdu.data);
    197196
    198         async_answer_0(icall_handle, rc);
    199 }
    200 
    201 static void inetping_get_srcaddr_srv(inetping_client_t *client,
    202     cap_call_handle_t icall_handle, ipc_call_t *icall)
     197        async_answer_0(icall, rc);
     198}
     199
     200static void inetping_get_srcaddr_srv(inetping_client_t *client, ipc_call_t *icall)
    203201{
    204202        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    205203
    206         cap_call_handle_t chandle;
     204        ipc_call_t call;
    207205        size_t size;
    208206
    … …  
    210208        inet_addr_t remote;
    211209
    212         if (!async_data_write_receive(&chandle, &size)) {
    213                 async_answer_0(chandle, EREFUSED);
    214                 async_answer_0(icall_handle, EREFUSED);
     210        if (!async_data_write_receive(&call, &size)) {
     211                async_answer_0(&call, EREFUSED);
     212                async_answer_0(icall, EREFUSED);
    215213                return;
    216214        }
    217215
    218216        if (size != sizeof(remote)) {
    219                 async_answer_0(chandle, EINVAL);
    220                 async_answer_0(icall_handle, EINVAL);
    221                 return;
    222         }
    223 
    224         errno_t rc = async_data_write_finalize(chandle, &remote, size);
    225         if (rc != EOK) {
    226                 async_answer_0(chandle, rc);
    227                 async_answer_0(icall_handle, rc);
     217                async_answer_0(&call, EINVAL);
     218                async_answer_0(icall, EINVAL);
     219                return;
     220        }
     221
     222        errno_t rc = async_data_write_finalize(&call, &remote, size);
     223        if (rc != EOK) {
     224                async_answer_0(&call, rc);
     225                async_answer_0(icall, rc);
    228226                return;
    229227        }
    … …  
    231229        rc = inetping_get_srcaddr(client, &remote, &local);
    232230        if (rc != EOK) {
    233                 async_answer_0(icall_handle, rc);
    234                 return;
    235         }
    236 
    237         if (!async_data_read_receive(&chandle, &size)) {
    238                 async_answer_0(chandle, EREFUSED);
    239                 async_answer_0(icall_handle, EREFUSED);
     231                async_answer_0(icall, rc);
     232                return;
     233        }
     234
     235        if (!async_data_read_receive(&call, &size)) {
     236                async_answer_0(&call, EREFUSED);
     237                async_answer_0(icall, EREFUSED);
    240238                return;
    241239        }
    242240
    243241        if (size != sizeof(local)) {
    244                 async_answer_0(chandle, EINVAL);
    245                 async_answer_0(icall_handle, EINVAL);
    246                 return;
    247         }
    248 
    249         rc = async_data_read_finalize(chandle, &local, size);
     242                async_answer_0(&call, EINVAL);
     243                async_answer_0(icall, EINVAL);
     244                return;
     245        }
     246
     247        rc = async_data_read_finalize(&call, &local, size);
    250248        if (rc != EOK)
    251                 async_answer_0(chandle, rc);
    252 
    253         async_answer_0(icall_handle, rc);
     249                async_answer_0(&call, rc);
     250
     251        async_answer_0(icall, rc);
    254252}
    255253
    … …  
    281279}
    282280
    283 void inetping_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     281void inetping_conn(ipc_call_t *icall, void *arg)
    284282{
    285283        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    286284
    287285        /* Accept the connection */
    288         async_answer_0(icall_handle, EOK);
     286        async_answer_0(icall, EOK);
    289287
    290288        inetping_client_t client;
    … …  
    295293        while (true) {
    296294                ipc_call_t call;
    297                 cap_call_handle_t chandle = async_get_call(&call);
     295                async_get_call(&call);
    298296                sysarg_t method = IPC_GET_IMETHOD(call);
    299297
    300298                if (!method) {
    301299                        /* The other side has hung up */
    302                         async_answer_0(chandle, EOK);
     300                        async_answer_0(&call, EOK);
    303301                        break;
    304302                }
    … …  
    306304                switch (method) {
    307305                case INETPING_SEND:
    308                         inetping_send_srv(&client, chandle, &call);
     306                        inetping_send_srv(&client, &call);
    309307                        break;
    310308                case INETPING_GET_SRCADDR:
    311                         inetping_get_srcaddr_srv(&client, chandle, &call);
     309                        inetping_get_srcaddr_srv(&client, &call);
    312310                        break;
    313311                default:
    314                         async_answer_0(chandle, EINVAL);
     312                        async_answer_0(&call, EINVAL);
    315313                }
    316314        }

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

    r76f566d r984a9ba  
    4141#include "inetsrv.h"
    4242
    43 extern void inetping_conn(cap_call_handle_t, ipc_call_t *, void *);
     43extern void inetping_conn(ipc_call_t *, void *);
    4444extern errno_t inetping_recv(uint16_t, inetping_sdu_t *);
    4545

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

    r76f566d r984a9ba  
    8282static LIST_INITIALIZE(client_list);
    8383
    84 static void inet_default_conn(cap_call_handle_t, ipc_call_t *, void *);
     84static void inet_default_conn(ipc_call_t *, void *);
    8585
    8686static errno_t inet_init(void)
    … …  
    120120}
    121121
    122 static void inet_callback_create_srv(inet_client_t *client, cap_call_handle_t chandle,
    123     ipc_call_t *call)
     122static void inet_callback_create_srv(inet_client_t *client, ipc_call_t *call)
    124123{
    125124        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_callback_create_srv()");
    … …  
    127126        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    128127        if (sess == NULL) {
    129                 async_answer_0(chandle, ENOMEM);
     128                async_answer_0(call, ENOMEM);
    130129                return;
    131130        }
    132131
    133132        client->sess = sess;
    134         async_answer_0(chandle, EOK);
     133        async_answer_0(call, EOK);
    135134}
    136135
    … …  
    230229}
    231230
    232 static void inet_get_srcaddr_srv(inet_client_t *client, cap_call_handle_t icall_handle,
    233     ipc_call_t *icall)
     231static void inet_get_srcaddr_srv(inet_client_t *client, ipc_call_t *icall)
    234232{
    235233        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
    … …  
    237235        uint8_t tos = IPC_GET_ARG1(*icall);
    238236
    239         cap_call_handle_t chandle;
     237        ipc_call_t call;
    240238        size_t size;
    241         if (!async_data_write_receive(&chandle, &size)) {
    242                 async_answer_0(chandle, EREFUSED);
    243                 async_answer_0(icall_handle, EREFUSED);
     239        if (!async_data_write_receive(&call, &size)) {
     240                async_answer_0(&call, EREFUSED);
     241                async_answer_0(icall, EREFUSED);
    244242                return;
    245243        }
    246244
    247245        if (size != sizeof(inet_addr_t)) {
    248                 async_answer_0(chandle, EINVAL);
    249                 async_answer_0(icall_handle, EINVAL);
     246                async_answer_0(&call, EINVAL);
     247                async_answer_0(icall, EINVAL);
    250248                return;
    251249        }
    252250
    253251        inet_addr_t remote;
    254         errno_t rc = async_data_write_finalize(chandle, &remote, size);
    255         if (rc != EOK) {
    256                 async_answer_0(chandle, rc);
    257                 async_answer_0(icall_handle, rc);
     252        errno_t rc = async_data_write_finalize(&call, &remote, size);
     253        if (rc != EOK) {
     254                async_answer_0(&call, rc);
     255                async_answer_0(icall, rc);
    258256        }
    259257
    … …  
    261259        rc = inet_get_srcaddr(&remote, tos, &local);
    262260        if (rc != EOK) {
    263                 async_answer_0(icall_handle, rc);
    264                 return;
    265         }
    266 
    267         if (!async_data_read_receive(&chandle, &size)) {
    268                 async_answer_0(chandle, EREFUSED);
    269                 async_answer_0(icall_handle, EREFUSED);
     261                async_answer_0(icall, rc);
     262                return;
     263        }
     264
     265        if (!async_data_read_receive(&call, &size)) {
     266                async_answer_0(&call, EREFUSED);
     267                async_answer_0(icall, EREFUSED);
    270268                return;
    271269        }
    272270
    273271        if (size != sizeof(inet_addr_t)) {
    274                 async_answer_0(chandle, EINVAL);
    275                 async_answer_0(icall_handle, EINVAL);
    276                 return;
    277         }
    278 
    279         rc = async_data_read_finalize(chandle, &local, size);
    280         if (rc != EOK) {
    281                 async_answer_0(chandle, rc);
    282                 async_answer_0(icall_handle, rc);
    283                 return;
    284         }
    285 
    286         async_answer_0(icall_handle, rc);
    287 }
    288 
    289 static void inet_send_srv(inet_client_t *client, cap_call_handle_t icall_handle,
    290     ipc_call_t *icall)
     272                async_answer_0(&call, EINVAL);
     273                async_answer_0(icall, EINVAL);
     274                return;
     275        }
     276
     277        rc = async_data_read_finalize(&call, &local, size);
     278        if (rc != EOK) {
     279                async_answer_0(&call, rc);
     280                async_answer_0(icall, rc);
     281                return;
     282        }
     283
     284        async_answer_0(icall, rc);
     285}
     286
     287static void inet_send_srv(inet_client_t *client, ipc_call_t *icall)
    291288{
    292289        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
    … …  
    300297        int df = IPC_GET_ARG4(*icall);
    301298
    302         cap_call_handle_t chandle;
     299        ipc_call_t call;
    303300        size_t size;
    304         if (!async_data_write_receive(&chandle, &size)) {
    305                 async_answer_0(chandle, EREFUSED);
    306                 async_answer_0(icall_handle, EREFUSED);
     301        if (!async_data_write_receive(&call, &size)) {
     302                async_answer_0(&call, EREFUSED);
     303                async_answer_0(icall, EREFUSED);
    307304                return;
    308305        }
    309306
    310307        if (size != sizeof(inet_addr_t)) {
    311                 async_answer_0(chandle, EINVAL);
    312                 async_answer_0(icall_handle, EINVAL);
    313                 return;
    314         }
    315 
    316         errno_t rc = async_data_write_finalize(chandle, &dgram.src, size);
    317         if (rc != EOK) {
    318                 async_answer_0(chandle, rc);
    319                 async_answer_0(icall_handle, rc);
    320         }
    321 
    322         if (!async_data_write_receive(&chandle, &size)) {
    323                 async_answer_0(chandle, EREFUSED);
    324                 async_answer_0(icall_handle, EREFUSED);
     308                async_answer_0(&call, EINVAL);
     309                async_answer_0(icall, EINVAL);
     310                return;
     311        }
     312
     313        errno_t rc = async_data_write_finalize(&call, &dgram.src, size);
     314        if (rc != EOK) {
     315                async_answer_0(&call, rc);
     316                async_answer_0(icall, rc);
     317        }
     318
     319        if (!async_data_write_receive(&call, &size)) {
     320                async_answer_0(&call, EREFUSED);
     321                async_answer_0(icall, EREFUSED);
    325322                return;
    326323        }
    327324
    328325        if (size != sizeof(inet_addr_t)) {
    329                 async_answer_0(chandle, EINVAL);
    330                 async_answer_0(icall_handle, EINVAL);
    331                 return;
    332         }
    333 
    334         rc = async_data_write_finalize(chandle, &dgram.dest, size);
    335         if (rc != EOK) {
    336                 async_answer_0(chandle, rc);
    337                 async_answer_0(icall_handle, rc);
     326                async_answer_0(&call, EINVAL);
     327                async_answer_0(icall, EINVAL);
     328                return;
     329        }
     330
     331        rc = async_data_write_finalize(&call, &dgram.dest, size);
     332        if (rc != EOK) {
     333                async_answer_0(&call, rc);
     334                async_answer_0(icall, rc);
    338335        }
    339336
    … …  
    341338            &dgram.size);
    342339        if (rc != EOK) {
    343                 async_answer_0(icall_handle, rc);
     340                async_answer_0(icall, rc);
    344341                return;
    345342        }
    … …  
    348345
    349346        free(dgram.data);
    350         async_answer_0(icall_handle, rc);
    351 }
    352 
    353 static void inet_set_proto_srv(inet_client_t *client, cap_call_handle_t chandle,
    354     ipc_call_t *call)
     347        async_answer_0(icall, rc);
     348}
     349
     350static void inet_set_proto_srv(inet_client_t *client, ipc_call_t *call)
    355351{
    356352        sysarg_t proto;
    … …  
    360356
    361357        if (proto > UINT8_MAX) {
    362                 async_answer_0(chandle, EINVAL);
     358                async_answer_0(call, EINVAL);
    363359                return;
    364360        }
    365361
    366362        client->protocol = proto;
    367         async_answer_0(chandle, EOK);
     363        async_answer_0(call, EOK);
    368364}
    369365
    … …  
    387383}
    388384
    389 static void inet_default_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     385static void inet_default_conn(ipc_call_t *icall, void *arg)
    390386{
    391387        inet_client_t client;
    … …  
    394390
    395391        /* Accept the connection */
    396         async_answer_0(icall_handle, EOK);
     392        async_answer_0(icall, EOK);
    397393
    398394        inet_client_init(&client);
    … …  
    400396        while (true) {
    401397                ipc_call_t call;
    402                 cap_call_handle_t chandle = async_get_call(&call);
     398                async_get_call(&call);
    403399                sysarg_t method = IPC_GET_IMETHOD(call);
    404400
    405401                if (!method) {
    406402                        /* The other side has hung up */
    407                         async_answer_0(chandle, EOK);
     403                        async_answer_0(&call, EOK);
    408404                        return;
    409405                }
    … …  
    411407                switch (method) {
    412408                case INET_CALLBACK_CREATE:
    413                         inet_callback_create_srv(&client, chandle, &call);
     409                        inet_callback_create_srv(&client, &call);
    414410                        break;
    415411                case INET_GET_SRCADDR:
    416                         inet_get_srcaddr_srv(&client, chandle, &call);
     412                        inet_get_srcaddr_srv(&client, &call);
    417413                        break;
    418414                case INET_SEND:
    419                         inet_send_srv(&client, chandle, &call);
     415                        inet_send_srv(&client, &call);
    420416                        break;
    421417                case INET_SET_PROTO:
    422                         inet_set_proto_srv(&client, chandle, &call);
     418                        inet_set_proto_srv(&client, &call);
    423419                        break;
    424420                default:
    425                         async_answer_0(chandle, EINVAL);
     421                        async_answer_0(&call, EINVAL);
    426422                }
    427423        }

  • uspace/srv/net/loopip/loopip.c

    r76f566d r984a9ba  
    5959static errno_t loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    6060
    61 static void loopip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     61static void loopip_client_conn(ipc_call_t *icall, void *arg);
    6262
    6363static iplink_ops_t loopip_iplink_ops = {
    … …  
    148148}
    149149
    150 static void loopip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     150static void loopip_client_conn(ipc_call_t *icall, void *arg)
    151151{
    152152        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_client_conn()");
    153         iplink_conn(icall_handle, icall, &loopip_iplink);
     153        iplink_conn(icall, &loopip_iplink);
    154154}
    155155

  • uspace/srv/net/nconfsrv/nconfsrv.c

    r76f566d r984a9ba  
    5454#define NAME "nconfsrv"
    5555
    56 static void ncs_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     56static void ncs_client_conn(ipc_call_t *icall, void *arg);
    5757
    5858static errno_t ncs_init(void)
    … …  
    9898}
    9999
    100 static void ncs_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     100static void ncs_client_conn(ipc_call_t *icall, void *arg)
    101101{
    102         async_answer_0(icall_handle, ENOTSUP);
     102        async_answer_0(icall, ENOTSUP);
    103103}
    104104

  • uspace/srv/net/slip/slip.c

    r76f566d r984a9ba  
    199199}
    200200
    201 static void slip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     201static void slip_client_conn(ipc_call_t *icall, void *arg)
    202202{
    203203        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_client_conn()");
    204         iplink_conn(icall_handle, icall, &slip_iplink);
     204        iplink_conn(icall, &slip_iplink);
    205205}
    206206

  • uspace/srv/net/tcp/service.c

    r76f566d r984a9ba  
    727727 * Handle client request to create callback session.
    728728 *
    729  * @param client        TCP client
    730  * @param icall_handle  Async request call handle
    731  * @param icall         Async request data
    732  */
    733 static void tcp_callback_create_srv(tcp_client_t *client,
    734     cap_call_handle_t icall_handle, ipc_call_t *icall)
     729 * @param client TCP client
     730 * @param icall  Async request data
     731 *
     732 */
     733static void tcp_callback_create_srv(tcp_client_t *client, ipc_call_t *icall)
    735734{
    736735        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_callback_create_srv()");
    … …  
    738737        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    739738        if (sess == NULL) {
    740                 async_answer_0(icall_handle, ENOMEM);
     739                async_answer_0(icall, ENOMEM);
    741740                return;
    742741        }
    743742
    744743        client->sess = sess;
    745         async_answer_0(icall_handle, EOK);
     744        async_answer_0(icall, EOK);
    746745}
    747746
    … …  
    750749 * Handle client request to create connection.
    751750 *
    752  * @param client        TCP client
    753  * @param icall_handle  Async request call handle
    754  * @param icall         Async request data
    755  */
    756 static void tcp_conn_create_srv(tcp_client_t *client,
    757     cap_call_handle_t icall_handle, ipc_call_t *icall)
    758 {
    759         cap_call_handle_t chandle;
     751 * @param client TCP client
     752 * @param icall  Async request data
     753 *
     754 */
     755static void tcp_conn_create_srv(tcp_client_t *client, ipc_call_t *icall)
     756{
     757        ipc_call_t call;
    760758        size_t size;
    761759        inet_ep2_t epp;
    … …  
    765763        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
    766764
    767         if (!async_data_write_receive(&chandle, &size)) {
    768                 async_answer_0(chandle, EREFUSED);
    769                 async_answer_0(icall_handle, EREFUSED);
     765        if (!async_data_write_receive(&call, &size)) {
     766                async_answer_0(&call, EREFUSED);
     767                async_answer_0(icall, EREFUSED);
    770768                return;
    771769        }
    772770
    773771        if (size != sizeof(inet_ep2_t)) {
    774                 async_answer_0(chandle, EINVAL);
    775                 async_answer_0(icall_handle, EINVAL);
    776                 return;
    777         }
    778 
    779         rc = async_data_write_finalize(chandle, &epp, size);
    780         if (rc != EOK) {
    781                 async_answer_0(chandle, rc);
    782                 async_answer_0(icall_handle, rc);
     772                async_answer_0(&call, EINVAL);
     773                async_answer_0(icall, EINVAL);
     774                return;
     775        }
     776
     777        rc = async_data_write_finalize(&call, &epp, size);
     778        if (rc != EOK) {
     779                async_answer_0(&call, rc);
     780                async_answer_0(icall, rc);
    783781                return;
    784782        }
    … …  
    786784        rc = tcp_conn_create_impl(client, &epp, &conn_id);
    787785        if (rc != EOK) {
    788                 async_answer_0(icall_handle, rc);
    789                 return;
    790         }
    791 
    792         async_answer_1(icall_handle, EOK, conn_id);
     786                async_answer_0(icall, rc);
     787                return;
     788        }
     789
     790        async_answer_1(icall, EOK, conn_id);
    793791}
    794792
    … …  
    797795 * Handle client request to destroy connection.
    798796 *
    799  * @param client        TCP client
    800  * @param icall_handle  Async request call handle
    801  * @param icall         Async request data
    802  */
    803 static void tcp_conn_destroy_srv(tcp_client_t *client,
    804     cap_call_handle_t icall_handle, ipc_call_t *icall)
     797 * @param client TCP client
     798 * @param icall  Async request data
     799 *
     800 */
     801static void tcp_conn_destroy_srv(tcp_client_t *client, ipc_call_t *icall)
    805802{
    806803        sysarg_t conn_id;
    … …  
    811808        conn_id = IPC_GET_ARG1(*icall);
    812809        rc = tcp_conn_destroy_impl(client, conn_id);
    813         async_answer_0(icall_handle, rc);
     810        async_answer_0(icall, rc);
    814811}
    815812
    … …  
    818815 * Handle client request to create listener.
    819816 *
    820  * @param client        TCP client
    821  * @param icall_handle  Async request call handle
    822  * @param icall         Async request data
    823  */
    824 static void tcp_listener_create_srv(tcp_client_t *client,
    825     cap_call_handle_t icall_handle, ipc_call_t *icall)
    826 {
    827         cap_call_handle_t chandle;
     817 * @param client TCP client
     818 * @param icall  Async request data
     819 *
     820 */
     821static void tcp_listener_create_srv(tcp_client_t *client, ipc_call_t *icall)
     822{
     823        ipc_call_t call;
    828824        size_t size;
    829825        inet_ep_t ep;
    … …  
    833829        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
    834830
    835         if (!async_data_write_receive(&chandle, &size)) {
    836                 async_answer_0(chandle, EREFUSED);
    837                 async_answer_0(icall_handle, EREFUSED);
     831        if (!async_data_write_receive(&call, &size)) {
     832                async_answer_0(&call, EREFUSED);
     833                async_answer_0(icall, EREFUSED);
    838834                return;
    839835        }
    840836
    841837        if (size != sizeof(inet_ep_t)) {
    842                 async_answer_0(chandle, EINVAL);
    843                 async_answer_0(icall_handle, EINVAL);
    844                 return;
    845         }
    846 
    847         rc = async_data_write_finalize(chandle, &ep, size);
    848         if (rc != EOK) {
    849                 async_answer_0(chandle, rc);
    850                 async_answer_0(icall_handle, rc);
     838                async_answer_0(&call, EINVAL);
     839                async_answer_0(icall, EINVAL);
     840                return;
     841        }
     842
     843        rc = async_data_write_finalize(&call, &ep, size);
     844        if (rc != EOK) {
     845                async_answer_0(&call, rc);
     846                async_answer_0(icall, rc);
    851847                return;
    852848        }
    … …  
    854850        rc = tcp_listener_create_impl(client, &ep, &lst_id);
    855851        if (rc != EOK) {
    856                 async_answer_0(icall_handle, rc);
    857                 return;
    858         }
    859 
    860         async_answer_1(icall_handle, EOK, lst_id);
     852                async_answer_0(icall, rc);
     853                return;
     854        }
     855
     856        async_answer_1(icall, EOK, lst_id);
    861857}
    862858
    … …  
    865861 * Handle client request to destroy listener.
    866862 *
    867  * @param client        TCP client
    868  * @param icall_handle  Async request call handle
    869  * @param icall         Async request data
    870  */
    871 static void tcp_listener_destroy_srv(tcp_client_t *client,
    872     cap_call_handle_t icall_handle, ipc_call_t *icall)
     863 * @param client TCP client
     864 * @param icall  Async request data
     865 *
     866 */
     867static void tcp_listener_destroy_srv(tcp_client_t *client, ipc_call_t *icall)
    873868{
    874869        sysarg_t lst_id;
    … …  
    879874        lst_id = IPC_GET_ARG1(*icall);
    880875        rc = tcp_listener_destroy_impl(client, lst_id);
    881         async_answer_0(icall_handle, rc);
     876        async_answer_0(icall, rc);
    882877}
    883878
    … …  
    886881 * Handle client request to send FIN.
    887882 *
    888  * @param client        TCP client
    889  * @param icall_handle  Async request call handle
    890  * @param icall         Async request data
    891  */
    892 static void tcp_conn_send_fin_srv(tcp_client_t *client,
    893     cap_call_handle_t icall_handle, ipc_call_t *icall)
     883 * @param client TCP client
     884 * @param icall  Async request data
     885 *
     886 */
     887static void tcp_conn_send_fin_srv(tcp_client_t *client, ipc_call_t *icall)
    894888{
    895889        sysarg_t conn_id;
    … …  
    900894        conn_id = IPC_GET_ARG1(*icall);
    901895        rc = tcp_conn_send_fin_impl(client, conn_id);
    902         async_answer_0(icall_handle, rc);
     896        async_answer_0(icall, rc);
    903897}
    904898
    … …  
    907901 * Handle client request to push connection.
    908902 *
    909  * @param client        TCP client
    910  * @param icall_handle  Async request call handle
    911  * @param icall         Async request data
    912  */
    913 static void tcp_conn_push_srv(tcp_client_t *client,
    914     cap_call_handle_t icall_handle, ipc_call_t *icall)
     903 * @param client TCP client
     904 * @param icall  Async request data
     905 *
     906 */
     907static void tcp_conn_push_srv(tcp_client_t *client, ipc_call_t *icall)
    915908{
    916909        sysarg_t conn_id;
    … …  
    921914        conn_id = IPC_GET_ARG1(*icall);
    922915        rc = tcp_conn_push_impl(client, conn_id);
    923         async_answer_0(icall_handle, rc);
     916        async_answer_0(icall, rc);
    924917}
    925918
    … …  
    928921 * Handle client request to reset connection.
    929922 *
    930  * @param client        TCP client
    931  * @param icall_handle  Async request call handle
    932  * @param icall         Async request data
    933  */
    934 static void tcp_conn_reset_srv(tcp_client_t *client,
    935     cap_call_handle_t icall_handle, ipc_call_t *icall)
     923 * @param client TCP client
     924 * @param icall  Async request data
     925 *
     926 */
     927static void tcp_conn_reset_srv(tcp_client_t *client, ipc_call_t *icall)
    936928{
    937929        sysarg_t conn_id;
    … …  
    942934        conn_id = IPC_GET_ARG1(*icall);
    943935        rc = tcp_conn_reset_impl(client, conn_id);
    944         async_answer_0(icall_handle, rc);
     936        async_answer_0(icall, rc);
    945937}
    946938
    … …  
    949941 * Handle client request to send data via connection.
    950942 *
    951  * @param client        TCP client
    952  * @param icall_handle  Async request call handle
    953  * @param icall         Async request data
    954  */
    955 static void tcp_conn_send_srv(tcp_client_t *client,
    956     cap_call_handle_t icall_handle, ipc_call_t *icall)
    957 {
    958         cap_call_handle_t chandle;
     943 * @param client TCP client
     944 * @param icall  Async request data
     945 *
     946 */
     947static void tcp_conn_send_srv(tcp_client_t *client, ipc_call_t *icall)
     948{
     949        ipc_call_t call;
    959950        size_t size;
    960951        sysarg_t conn_id;
    … …  
    966957        /* Receive message data */
    967958
    968         if (!async_data_write_receive(&chandle, &size)) {
    969                 async_answer_0(chandle, EREFUSED);
    970                 async_answer_0(icall_handle, EREFUSED);
     959        if (!async_data_write_receive(&call, &size)) {
     960                async_answer_0(&call, EREFUSED);
     961                async_answer_0(icall, EREFUSED);
    971962                return;
    972963        }
    973964
    974965        if (size > MAX_MSG_SIZE) {
    975                 async_answer_0(chandle, EINVAL);
    976                 async_answer_0(icall_handle, EINVAL);
     966                async_answer_0(&call, EINVAL);
     967                async_answer_0(icall, EINVAL);
    977968                return;
    978969        }
    … …  
    980971        data = malloc(size);
    981972        if (data == NULL) {
    982                 async_answer_0(chandle, ENOMEM);
    983                 async_answer_0(icall_handle, ENOMEM);
    984                 return;
    985         }
    986 
    987         rc = async_data_write_finalize(chandle, data, size);
    988         if (rc != EOK) {
    989                 async_answer_0(chandle, rc);
    990                 async_answer_0(icall_handle, rc);
     973                async_answer_0(&call, ENOMEM);
     974                async_answer_0(icall, ENOMEM);
     975                return;
     976        }
     977
     978        rc = async_data_write_finalize(&call, data, size);
     979        if (rc != EOK) {
     980                async_answer_0(&call, rc);
     981                async_answer_0(icall, rc);
    991982                free(data);
    992983                return;
    … …  
    997988        rc = tcp_conn_send_impl(client, conn_id, data, size);
    998989        if (rc != EOK) {
    999                 async_answer_0(icall_handle, rc);
     990                async_answer_0(icall, rc);
    1000991                free(data);
    1001992                return;
    1002993        }
    1003994
    1004         async_answer_0(icall_handle, EOK);
     995        async_answer_0(icall, EOK);
    1005996        free(data);
    1006997}
    … …  
    10101001 * Handle client request to read received data via connection without blocking.
    10111002 *
    1012  * @param client        TCP client
    1013  * @param icall_handle  Async request call handle
    1014  * @param icall         Async request data
    1015  */
    1016 static void tcp_conn_recv_srv(tcp_client_t *client,
    1017     cap_call_handle_t icall_handle, ipc_call_t *icall)
    1018 {
    1019         cap_call_handle_t chandle;
     1003 * @param client TCP client
     1004 * @param icall  Async request data
     1005 *
     1006 */
     1007static void tcp_conn_recv_srv(tcp_client_t *client, ipc_call_t *icall)
     1008{
     1009        ipc_call_t call;
    10201010        sysarg_t conn_id;
    10211011        size_t size, rsize;
    … …  
    10271017        conn_id = IPC_GET_ARG1(*icall);
    10281018
    1029         if (!async_data_read_receive(&chandle, &size)) {
    1030                 async_answer_0(chandle, EREFUSED);
    1031                 async_answer_0(icall_handle, EREFUSED);
     1019        if (!async_data_read_receive(&call, &size)) {
     1020                async_answer_0(&call, EREFUSED);
     1021                async_answer_0(icall, EREFUSED);
    10321022                return;
    10331023        }
    … …  
    10361026        data = malloc(size);
    10371027        if (data == NULL) {
    1038                 async_answer_0(chandle, ENOMEM);
    1039                 async_answer_0(icall_handle, ENOMEM);
     1028                async_answer_0(&call, ENOMEM);
     1029                async_answer_0(icall, ENOMEM);
    10401030                return;
    10411031        }
    … …  
    10431033        rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
    10441034        if (rc != EOK) {
    1045                 async_answer_0(chandle, rc);
    1046                 async_answer_0(icall_handle, rc);
     1035                async_answer_0(&call, rc);
     1036                async_answer_0(icall, rc);
    10471037                free(data);
    10481038                return;
    10491039        }
    10501040
    1051         rc = async_data_read_finalize(chandle, data, size);
    1052         if (rc != EOK) {
    1053                 async_answer_0(icall_handle, rc);
     1041        rc = async_data_read_finalize(&call, data, size);
     1042        if (rc != EOK) {
     1043                async_answer_0(icall, rc);
    10541044                free(data);
    10551045                return;
    10561046        }
    10571047
    1058         async_answer_1(icall_handle, EOK, rsize);
     1048        async_answer_1(icall, EOK, rsize);
    10591049        free(data);
    10601050
    … …  
    10661056 * Handle client request to read received data via connection with blocking.
    10671057 *
    1068  * @param client        TCP client
    1069  * @param icall_handle  Async request call handle
    1070  * @param icall         Async request data
    1071  */
    1072 static void tcp_conn_recv_wait_srv(tcp_client_t *client,
    1073     cap_call_handle_t icall_handle, ipc_call_t *icall)
    1074 {
    1075         cap_call_handle_t chandle;
     1058 * @param client TCP client
     1059 * @param icall  Async request data
     1060 *
     1061 */
     1062static void tcp_conn_recv_wait_srv(tcp_client_t *client, ipc_call_t *icall)
     1063{
     1064        ipc_call_t call;
    10761065        sysarg_t conn_id;
    10771066        size_t size, rsize;
    … …  
    10831072        conn_id = IPC_GET_ARG1(*icall);
    10841073
    1085         if (!async_data_read_receive(&chandle, &size)) {
     1074        if (!async_data_read_receive(&call, &size)) {
    10861075                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - data_receive failed");
    1087                 async_answer_0(chandle, EREFUSED);
    1088                 async_answer_0(icall_handle, EREFUSED);
     1076                async_answer_0(&call, EREFUSED);
     1077                async_answer_0(icall, EREFUSED);
    10891078                return;
    10901079        }
    … …  
    10941083        if (data == NULL) {
    10951084                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - allocation failed");
    1096                 async_answer_0(chandle, ENOMEM);
    1097                 async_answer_0(icall_handle, ENOMEM);
     1085                async_answer_0(&call, ENOMEM);
     1086                async_answer_0(icall, ENOMEM);
    10981087                return;
    10991088        }
    … …  
    11021091        if (rc != EOK) {
    11031092                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - recv_impl failed rc=%s", str_error_name(rc));
    1104                 async_answer_0(chandle, rc);
    1105                 async_answer_0(icall_handle, rc);
     1093                async_answer_0(&call, rc);
     1094                async_answer_0(icall, rc);
    11061095                free(data);
    11071096                return;
    11081097        }
    11091098
    1110         rc = async_data_read_finalize(chandle, data, size);
     1099        rc = async_data_read_finalize(&call, data, size);
    11111100        if (rc != EOK) {
    11121101                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - finalize failed");
    1113                 async_answer_0(icall_handle, rc);
     1102                async_answer_0(icall, rc);
    11141103                free(data);
    11151104                return;
    … …  
    11171106
    11181107        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): rsize=%zu", size);
    1119         async_answer_1(icall_handle, EOK, rsize);
     1108        async_answer_1(icall, EOK, rsize);
    11201109        free(data);
    11211110
    … …  
    11711160/** Handle TCP client connection.
    11721161 *
    1173  * @param icall_handle  Connect call handle
    1174  * @param icall         Connect call data
    1175  * @param arg           Connection argument
    1176  */
    1177 static void tcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
    1178     void *arg)
     1162 * @param icall Connect call data
     1163 * @param arg   Connection argument
     1164 *
     1165 */
     1166static void tcp_client_conn(ipc_call_t *icall, void *arg)
    11791167{
    11801168        tcp_client_t client;
    11811169
    11821170        /* Accept the connection */
    1183         async_answer_0(icall_handle, EOK);
     1171        async_answer_0(icall, EOK);
    11841172
    11851173        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn() - client=%p",
    … …  
    11911179                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: wait req");
    11921180                ipc_call_t call;
    1193                 cap_call_handle_t chandle = async_get_call(&call);
     1181                async_get_call(&call);
    11941182                sysarg_t method = IPC_GET_IMETHOD(call);
    11951183
    … …  
    11981186                if (!method) {
    11991187                        /* The other side has hung up */
    1200                         async_answer_0(chandle, EOK);
     1188                        async_answer_0(&call, EOK);
    12011189                        break;
    12021190                }
    … …  
    12041192                switch (method) {
    12051193                case TCP_CALLBACK_CREATE:
    1206                         tcp_callback_create_srv(&client, chandle, &call);
     1194                        tcp_callback_create_srv(&client, &call);
    12071195                        break;
    12081196                case TCP_CONN_CREATE:
    1209                         tcp_conn_create_srv(&client, chandle, &call);
     1197                        tcp_conn_create_srv(&client, &call);
    12101198                        break;
    12111199                case TCP_CONN_DESTROY:
    1212                         tcp_conn_destroy_srv(&client, chandle, &call);
     1200                        tcp_conn_destroy_srv(&client, &call);
    12131201                        break;
    12141202                case TCP_LISTENER_CREATE:
    1215                         tcp_listener_create_srv(&client, chandle, &call);
     1203                        tcp_listener_create_srv(&client, &call);
    12161204                        break;
    12171205                case TCP_LISTENER_DESTROY:
    1218                         tcp_listener_destroy_srv(&client, chandle, &call);
     1206                        tcp_listener_destroy_srv(&client, &call);
    12191207                        break;
    12201208                case TCP_CONN_SEND_FIN:
    1221                         tcp_conn_send_fin_srv(&client, chandle, &call);
     1209                        tcp_conn_send_fin_srv(&client, &call);
    12221210                        break;
    12231211                case TCP_CONN_PUSH:
    1224                         tcp_conn_push_srv(&client, chandle, &call);
     1212                        tcp_conn_push_srv(&client, &call);
    12251213                        break;
    12261214                case TCP_CONN_RESET:
    1227                         tcp_conn_reset_srv(&client, chandle, &call);
     1215                        tcp_conn_reset_srv(&client, &call);
    12281216                        break;
    12291217                case TCP_CONN_SEND:
    1230                         tcp_conn_send_srv(&client, chandle, &call);
     1218                        tcp_conn_send_srv(&client, &call);
    12311219                        break;
    12321220                case TCP_CONN_RECV:
    1233                         tcp_conn_recv_srv(&client, chandle, &call);
     1221                        tcp_conn_recv_srv(&client, &call);
    12341222                        break;
    12351223                case TCP_CONN_RECV_WAIT:
    1236                         tcp_conn_recv_wait_srv(&client, chandle, &call);
     1224                        tcp_conn_recv_wait_srv(&client, &call);
    12371225                        break;
    12381226                default:
    1239                         async_answer_0(chandle, ENOTSUP);
     1227                        async_answer_0(&call, ENOTSUP);
    12401228                        break;
    12411229                }

  • uspace/srv/net/udp/service.c

    r76f566d r984a9ba  
    326326 * Handle client request to create callback session.
    327327 *
    328  * @param client        UDP client
    329  * @param icall_handle  Async request call handle
    330  * @param icall         Async request data
    331  */
    332 static void
    333 udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    334     ipc_call_t *icall)
     328 * @param client UDP client
     329 * @param icall  Async request data
     330 *
     331 */
     332static void udp_callback_create_srv(udp_client_t *client, ipc_call_t *icall)
    335333{
    336334        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_callback_create_srv()");
    … …  
    338336        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    339337        if (sess == NULL) {
    340                 async_answer_0(icall_handle, ENOMEM);
     338                async_answer_0(icall, ENOMEM);
    341339                return;
    342340        }
    343341
    344342        client->sess = sess;
    345         async_answer_0(icall_handle, EOK);
     343        async_answer_0(icall, EOK);
    346344}
    347345
    … …  
    350348 * Handle client request to create association.
    351349 *
    352  * @param client        UDP client
    353  * @param icall_handle  Async request call handle
    354  * @param icall         Async request data
    355  */
    356 static void
    357 udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    358     ipc_call_t *icall)
    359 {
    360         cap_call_handle_t chandle;
     350 * @param client UDP client
     351 * @param icall  Async request data
     352 *
     353 */
     354static void udp_assoc_create_srv(udp_client_t *client, ipc_call_t *icall)
     355{
     356        ipc_call_t call;
    361357        size_t size;
    362358        inet_ep2_t epp;
    … …  
    366362        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
    367363
    368         if (!async_data_write_receive(&chandle, &size)) {
    369                 async_answer_0(chandle, EREFUSED);
    370                 async_answer_0(icall_handle, EREFUSED);
     364        if (!async_data_write_receive(&call, &size)) {
     365                async_answer_0(&call, EREFUSED);
     366                async_answer_0(icall, EREFUSED);
    371367                return;
    372368        }
    373369
    374370        if (size != sizeof(inet_ep2_t)) {
    375                 async_answer_0(chandle, EINVAL);
    376                 async_answer_0(icall_handle, EINVAL);
    377                 return;
    378         }
    379 
    380         rc = async_data_write_finalize(chandle, &epp, size);
    381         if (rc != EOK) {
    382                 async_answer_0(chandle, rc);
    383                 async_answer_0(icall_handle, rc);
     371                async_answer_0(&call, EINVAL);
     372                async_answer_0(icall, EINVAL);
     373                return;
     374        }
     375
     376        rc = async_data_write_finalize(&call, &epp, size);
     377        if (rc != EOK) {
     378                async_answer_0(&call, rc);
     379                async_answer_0(icall, rc);
    384380                return;
    385381        }
    … …  
    387383        rc = udp_assoc_create_impl(client, &epp, &assoc_id);
    388384        if (rc != EOK) {
    389                 async_answer_0(icall_handle, rc);
    390                 return;
    391         }
    392 
    393         async_answer_1(icall_handle, EOK, assoc_id);
     385                async_answer_0(icall, rc);
     386                return;
     387        }
     388
     389        async_answer_1(icall, EOK, assoc_id);
    394390}
    395391
    … …  
    398394 * Handle client request to destroy association.
    399395 *
    400  * @param client        UDP client
    401  * @param icall_handle  Async request call handle
    402  * @param icall         Async request data
    403  */
    404 static void
    405 udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    406     ipc_call_t *icall)
     396 * @param client UDP client
     397 * @param icall  Async request data
     398 *
     399 */
     400static void udp_assoc_destroy_srv(udp_client_t *client, ipc_call_t *icall)
    407401{
    408402        sysarg_t assoc_id;
    … …  
    413407        assoc_id = IPC_GET_ARG1(*icall);
    414408        rc = udp_assoc_destroy_impl(client, assoc_id);
    415         async_answer_0(icall_handle, rc);
     409        async_answer_0(icall, rc);
    416410}
    417411
    … …  
    420414 * Handle client request to set no local address flag.
    421415 *
    422  * @param client        UDP client
    423  * @param icall_handle  Async request call handle
    424  * @param icall         Async request data
    425  */
    426 static void
    427 udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    428     ipc_call_t *icall)
     416 * @param client UDP client
     417 * @param icall  Async request data
     418 *
     419 */
     420static void udp_assoc_set_nolocal_srv(udp_client_t *client, ipc_call_t *icall)
    429421{
    430422        sysarg_t assoc_id;
    … …  
    435427        assoc_id = IPC_GET_ARG1(*icall);
    436428        rc = udp_assoc_set_nolocal_impl(client, assoc_id);
    437         async_answer_0(icall_handle, rc);
     429        async_answer_0(icall, rc);
    438430}
    439431
    … …  
    442434 * Handle client request to send message.
    443435 *
    444  * @param client        UDP client
    445  * @param icall_handle  Async request call handle
    446  * @param icall         Async request data
    447  */
    448 static void
    449 udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    450     ipc_call_t *icall)
    451 {
    452         cap_call_handle_t chandle;
     436 * @param client UDP client
     437 * @param icall  Async request data
     438 *
     439 */
     440static void udp_assoc_send_msg_srv(udp_client_t *client, ipc_call_t *icall)
     441{
     442        ipc_call_t call;
    453443        size_t size;
    454444        inet_ep_t dest;
    … …  
    461451        /* Receive dest */
    462452
    463         if (!async_data_write_receive(&chandle, &size)) {
    464                 async_answer_0(chandle, EREFUSED);
    465                 async_answer_0(icall_handle, EREFUSED);
     453        if (!async_data_write_receive(&call, &size)) {
     454                async_answer_0(&call, EREFUSED);
     455                async_answer_0(icall, EREFUSED);
    466456                return;
    467457        }
    468458
    469459        if (size != sizeof(inet_ep_t)) {
    470                 async_answer_0(chandle, EINVAL);
    471                 async_answer_0(icall_handle, EINVAL);
    472                 return;
    473         }
    474 
    475         rc = async_data_write_finalize(chandle, &dest, size);
    476         if (rc != EOK) {
    477                 async_answer_0(chandle, rc);
    478                 async_answer_0(icall_handle, rc);
     460                async_answer_0(&call, EINVAL);
     461                async_answer_0(icall, EINVAL);
     462                return;
     463        }
     464
     465        rc = async_data_write_finalize(&call, &dest, size);
     466        if (rc != EOK) {
     467                async_answer_0(&call, rc);
     468                async_answer_0(icall, rc);
    479469                return;
    480470        }
    … …  
    482472        /* Receive message data */
    483473
    484         if (!async_data_write_receive(&chandle, &size)) {
    485                 async_answer_0(chandle, EREFUSED);
    486                 async_answer_0(icall_handle, EREFUSED);
     474        if (!async_data_write_receive(&call, &size)) {
     475                async_answer_0(&call, EREFUSED);
     476                async_answer_0(icall, EREFUSED);
    487477                return;
    488478        }
    489479
    490480        if (size > MAX_MSG_SIZE) {
    491                 async_answer_0(chandle, EINVAL);
    492                 async_answer_0(icall_handle, EINVAL);
     481                async_answer_0(&call, EINVAL);
     482                async_answer_0(icall, EINVAL);
    493483                return;
    494484        }
    … …  
    496486        data = malloc(size);
    497487        if (data == NULL) {
    498                 async_answer_0(chandle, ENOMEM);
    499                 async_answer_0(icall_handle, ENOMEM);
    500         }
    501 
    502         rc = async_data_write_finalize(chandle, data, size);
    503         if (rc != EOK) {
    504                 async_answer_0(chandle, rc);
    505                 async_answer_0(icall_handle, rc);
     488                async_answer_0(&call, ENOMEM);
     489                async_answer_0(icall, ENOMEM);
     490        }
     491
     492        rc = async_data_write_finalize(&call, data, size);
     493        if (rc != EOK) {
     494                async_answer_0(&call, rc);
     495                async_answer_0(icall, rc);
    506496                free(data);
    507497                return;
    … …  
    512502        rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
    513503        if (rc != EOK) {
    514                 async_answer_0(icall_handle, rc);
     504                async_answer_0(icall, rc);
    515505                free(data);
    516506                return;
    517507        }
    518508
    519         async_answer_0(icall_handle, EOK);
     509        async_answer_0(icall, EOK);
    520510        free(data);
    521511}
    … …  
    541531 * Handle client request to get information on received message.
    542532 *
    543  * @param client        UDP client
    544  * @param icall_handle  Async request call handle
    545  * @param icall         Async request data
    546  */
    547 static void
    548 udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    549     ipc_call_t *icall)
    550 {
    551         cap_call_handle_t chandle;
     533 * @param client UDP client
     534 * @param icall  Async request data
     535 *
     536 */
     537static void udp_rmsg_info_srv(udp_client_t *client, ipc_call_t *icall)
     538{
     539        ipc_call_t call;
    552540        size_t size;
    553541        udp_crcv_queue_entry_t *enext;
    … …  
    558546        enext = udp_rmsg_get_next(client);
    559547
    560         if (!async_data_read_receive(&chandle, &size)) {
    561                 async_answer_0(chandle, EREFUSED);
    562                 async_answer_0(icall_handle, EREFUSED);
     548        if (!async_data_read_receive(&call, &size)) {
     549                async_answer_0(&call, EREFUSED);
     550                async_answer_0(icall, EREFUSED);
    563551                return;
    564552        }
    565553
    566554        if (enext == NULL) {
    567                 async_answer_0(chandle, ENOENT);
    568                 async_answer_0(icall_handle, ENOENT);
    569                 return;
    570         }
    571 
    572         rc = async_data_read_finalize(chandle, &enext->epp.remote,
     555                async_answer_0(&call, ENOENT);
     556                async_answer_0(icall, ENOENT);
     557                return;
     558        }
     559
     560        rc = async_data_read_finalize(&call, &enext->epp.remote,
    573561            max(size, (size_t)sizeof(inet_ep_t)));
    574562        if (rc != EOK) {
    575                 async_answer_0(icall_handle, rc);
     563                async_answer_0(icall, rc);
    576564                return;
    577565        }
    … …  
    582570        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
    583571            "size=%zu", assoc_id, size);
    584         async_answer_2(icall_handle, EOK, assoc_id, size);
     572        async_answer_2(icall, EOK, assoc_id, size);
    585573}
    586574
    … …  
    589577 * Handle client request to read data from first received message.
    590578 *
    591  * @param client        UDP client
    592  * @param icall_handle  Async request call handle
    593  * @param icall         Async request data
    594  */
    595 static void
    596 udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    597     ipc_call_t *icall)
    598 {
    599         cap_call_handle_t chandle;
     579 * @param client UDP client
     580 * @param icall  Async request data
     581 *
     582 */
     583static void udp_rmsg_read_srv(udp_client_t *client, ipc_call_t *icall)
     584{
     585        ipc_call_t call;
    600586        size_t msg_size;
    601587        udp_crcv_queue_entry_t *enext;
    … …  
    610596        enext = udp_rmsg_get_next(client);
    611597
    612         if (!async_data_read_receive(&chandle, &size)) {
    613                 async_answer_0(chandle, EREFUSED);
    614                 async_answer_0(icall_handle, EREFUSED);
     598        if (!async_data_read_receive(&call, &size)) {
     599                async_answer_0(&call, EREFUSED);
     600                async_answer_0(icall, EREFUSED);
    615601                return;
    616602        }
    617603
    618604        if (enext == NULL) {
    619                 async_answer_0(chandle, ENOENT);
    620                 async_answer_0(icall_handle, ENOENT);
     605                async_answer_0(&call, ENOENT);
     606                async_answer_0(icall, ENOENT);
    621607                return;
    622608        }
    … …  
    626612
    627613        if (off > msg_size) {
    628                 async_answer_0(chandle, EINVAL);
    629                 async_answer_0(icall_handle, EINVAL);
    630                 return;
    631         }
    632 
    633         rc = async_data_read_finalize(chandle, data, min(msg_size - off, size));
    634         if (rc != EOK) {
    635                 async_answer_0(icall_handle, rc);
    636                 return;
    637         }
    638 
    639         async_answer_0(icall_handle, EOK);
     614                async_answer_0(&call, EINVAL);
     615                async_answer_0(icall, EINVAL);
     616                return;
     617        }
     618
     619        rc = async_data_read_finalize(&call, data, min(msg_size - off, size));
     620        if (rc != EOK) {
     621                async_answer_0(icall, rc);
     622                return;
     623        }
     624
     625        async_answer_0(icall, EOK);
    640626        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
    641627}
    … …  
    646632 * to the next one.
    647633 *
    648  * @param client        UDP client
    649  * @param icall_handle  Async request call handle
    650  * @param icall         Async request data
    651  */
    652 static void
    653 udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    654     ipc_call_t *icall)
     634 * @param client UDP client
     635 * @param icall  Async request data
     636 *
     637 */
     638static void udp_rmsg_discard_srv(udp_client_t *client, ipc_call_t *icall)
    655639{
    656640        udp_crcv_queue_entry_t *enext;
    … …  
    661645        if (enext == NULL) {
    662646                log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
    663                 async_answer_0(icall_handle, ENOENT);
     647                async_answer_0(icall, ENOENT);
    664648                return;
    665649        }
    … …  
    668652        udp_msg_delete(enext->msg);
    669653        free(enext);
    670         async_answer_0(icall_handle, EOK);
     654        async_answer_0(icall, EOK);
    671655}
    672656
    673657/** Handle UDP client connection.
    674658 *
    675  * @param icall_handle  Connect call handle
    676  * @param icall         Connect call data
    677  * @param arg           Connection argument
    678  */
    679 static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
    680     void *arg)
     659 * @param icall Connect call data
     660 * @param arg   Connection argument
     661 *
     662 */
     663static void udp_client_conn(ipc_call_t *icall, void *arg)
    681664{
    682665        udp_client_t client;
    … …  
    684667
    685668        /* Accept the connection */
    686         async_answer_0(icall_handle, EOK);
     669        async_answer_0(icall, EOK);
    687670
    688671        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
    … …  
    695678                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
    696679                ipc_call_t call;
    697                 cap_call_handle_t chandle = async_get_call(&call);
     680                async_get_call(&call);
    698681                sysarg_t method = IPC_GET_IMETHOD(call);
    699682
    … …  
    702685                if (!method) {
    703686                        /* The other side has hung up */
    704                         async_answer_0(chandle, EOK);
     687                        async_answer_0(&call, EOK);
    705688                        break;
    706689                }
    … …  
    708691                switch (method) {
    709692                case UDP_CALLBACK_CREATE:
    710                         udp_callback_create_srv(&client, chandle, &call);
     693                        udp_callback_create_srv(&client, &call);
    711694                        break;
    712695                case UDP_ASSOC_CREATE:
    713                         udp_assoc_create_srv(&client, chandle, &call);
     696                        udp_assoc_create_srv(&client, &call);
    714697                        break;
    715698                case UDP_ASSOC_DESTROY:
    716                         udp_assoc_destroy_srv(&client, chandle, &call);
     699                        udp_assoc_destroy_srv(&client, &call);
    717700                        break;
    718701                case UDP_ASSOC_SET_NOLOCAL:
    719                         udp_assoc_set_nolocal_srv(&client, chandle, &call);
     702                        udp_assoc_set_nolocal_srv(&client, &call);
    720703                        break;
    721704                case UDP_ASSOC_SEND_MSG:
    722                         udp_assoc_send_msg_srv(&client, chandle, &call);
     705                        udp_assoc_send_msg_srv(&client, &call);
    723706                        break;
    724707                case UDP_RMSG_INFO:
    725                         udp_rmsg_info_srv(&client, chandle, &call);
     708                        udp_rmsg_info_srv(&client, &call);
    726709                        break;
    727710                case UDP_RMSG_READ:
    728                         udp_rmsg_read_srv(&client, chandle, &call);
     711                        udp_rmsg_read_srv(&client, &call);
    729712                        break;
    730713                case UDP_RMSG_DISCARD:
    731                         udp_rmsg_discard_srv(&client, chandle, &call);
     714                        udp_rmsg_discard_srv(&client, &call);
    732715                        break;
    733716                default:
    734                         async_answer_0(chandle, ENOTSUP);
     717                        async_answer_0(&call, ENOTSUP);
    735718                        break;
    736719                }
Note: See TracChangeset for help on using the changeset viewer.