Changeset a46e56b in mainline for uspace/srv/net


Ignore:
Timestamp:
2018-03-22T06:49:35Z (8 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

Location:
uspace/srv/net
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r3e242d2 ra46e56b  
    8484}
    8585
    86 static void dhcp_link_add_srv(cap_call_handle_t callid, ipc_call_t *call)
     86static void dhcp_link_add_srv(cap_call_handle_t chandle, ipc_call_t *call)
    8787{
    8888        sysarg_t link_id;
    … …  
    9494
    9595        rc = dhcpsrv_link_add(link_id);
    96         async_answer_0(callid, rc);
     96        async_answer_0(chandle, rc);
    9797}
    9898
    99 static void dhcp_link_remove_srv(cap_call_handle_t callid, ipc_call_t *call)
     99static void dhcp_link_remove_srv(cap_call_handle_t chandle, ipc_call_t *call)
    100100{
    101101        sysarg_t link_id;
    … …  
    107107
    108108        rc = dhcpsrv_link_remove(link_id);
    109         async_answer_0(callid, rc);
     109        async_answer_0(chandle, rc);
    110110}
    111111
    112 static void dhcp_discover_srv(cap_call_handle_t callid, ipc_call_t *call)
     112static void dhcp_discover_srv(cap_call_handle_t chandle, ipc_call_t *call)
    113113{
    114114        sysarg_t link_id;
    … …  
    120120
    121121        rc = dhcpsrv_discover(link_id);
    122         async_answer_0(callid, rc);
     122        async_answer_0(chandle, rc);
    123123}
    124124
    125 static void dhcp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     125static void dhcp_client_conn(cap_call_handle_t icall_handle, 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(iid, EOK);
     130        async_answer_0(icall_handle, EOK);
    131131
    132132        while (true) {
    133133                ipc_call_t call;
    134                 cap_call_handle_t callid = async_get_call(&call);
     134                cap_call_handle_t chandle = 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(callid, EOK);
     139                        async_answer_0(chandle, EOK);
    140140                        return;
    141141                }
    … …  
    143143                switch (method) {
    144144                case DHCP_LINK_ADD:
    145                         dhcp_link_add_srv(callid, &call);
     145                        dhcp_link_add_srv(chandle, &call);
    146146                        break;
    147147                case DHCP_LINK_REMOVE:
    148                         dhcp_link_remove_srv(callid, &call);
     148                        dhcp_link_remove_srv(chandle, &call);
    149149                        break;
    150150                case DHCP_DISCOVER:
    151                         dhcp_discover_srv(callid, &call);
     151                        dhcp_discover_srv(chandle, &call);
    152152                        break;
    153153                default:
    154                         async_answer_0(callid, EINVAL);
     154                        async_answer_0(chandle, EINVAL);
    155155                }
    156156        }

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

    r3e242d2 ra46e56b  
    8686}
    8787
    88 static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t iid,
     88static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    8989    ipc_call_t *icall)
    9090{
    … …  
    9797            DNS_NAME_MAX_SIZE, 0, NULL);
    9898        if (rc != EOK) {
    99                 async_answer_0(iid, rc);
     99                async_answer_0(icall_handle, rc);
    100100                return;
    101101        }
    … …  
    104104        rc = dns_name2host(name, &hinfo, ver);
    105105        if (rc != EOK) {
    106                 async_answer_0(iid, rc);
    107                 return;
    108         }
    109 
    110         cap_call_handle_t callid;
     106                async_answer_0(icall_handle, rc);
     107                return;
     108        }
     109
     110        cap_call_handle_t chandle;
    111111        size_t size;
    112         if (!async_data_read_receive(&callid, &size)) {
    113                 async_answer_0(callid, EREFUSED);
    114                 async_answer_0(iid, EREFUSED);
     112        if (!async_data_read_receive(&chandle, &size)) {
     113                async_answer_0(chandle, EREFUSED);
     114                async_answer_0(icall_handle, EREFUSED);
    115115                return;
    116116        }
    117117
    118118        if (size != sizeof(inet_addr_t)) {
    119                 async_answer_0(callid, EINVAL);
    120                 async_answer_0(iid, EINVAL);
    121                 return;
    122         }
    123 
    124         rc = async_data_read_finalize(callid, &hinfo->addr, size);
    125         if (rc != EOK) {
    126                 async_answer_0(callid, rc);
    127                 async_answer_0(iid, rc);
    128                 return;
    129         }
    130 
    131         if (!async_data_read_receive(&callid, &size)) {
    132                 async_answer_0(callid, EREFUSED);
    133                 async_answer_0(iid, EREFUSED);
     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);
    134134                return;
    135135        }
    … …  
    137137        size_t act_size = str_size(hinfo->cname);
    138138        if (act_size > size) {
    139                 async_answer_0(callid, EINVAL);
    140                 async_answer_0(iid, EINVAL);
    141                 return;
    142         }
    143 
    144         rc = async_data_read_finalize(callid, hinfo->cname, act_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);
    145145        if (rc != EOK)
    146                 async_answer_0(callid, rc);
    147 
    148         async_answer_0(iid, rc);
     146                async_answer_0(chandle, rc);
     147
     148        async_answer_0(icall_handle, rc);
    149149
    150150        dns_hostinfo_destroy(hinfo);
    151151}
    152152
    153 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t iid,
     153static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    154154    ipc_call_t *icall)
    155155{
    156156        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    157157
    158         cap_call_handle_t callid;
     158        cap_call_handle_t chandle;
    159159        size_t size;
    160         if (!async_data_read_receive(&callid, &size)) {
    161                 async_answer_0(callid, EREFUSED);
    162                 async_answer_0(iid, EREFUSED);
     160        if (!async_data_read_receive(&chandle, &size)) {
     161                async_answer_0(chandle, EREFUSED);
     162                async_answer_0(icall_handle, EREFUSED);
    163163                return;
    164164        }
    165165
    166166        if (size != sizeof(inet_addr_t)) {
    167                 async_answer_0(callid, EINVAL);
    168                 async_answer_0(iid, EINVAL);
     167                async_answer_0(chandle, EINVAL);
     168                async_answer_0(icall_handle, EINVAL);
    169169                return;
    170170        }
    … …  
    172172        // FIXME locking
    173173
    174         errno_t rc = async_data_read_finalize(callid, &dns_server_addr, size);
     174        errno_t rc = async_data_read_finalize(chandle, &dns_server_addr, size);
    175175        if (rc != EOK)
    176                 async_answer_0(callid, rc);
    177 
    178         async_answer_0(iid, rc);
    179 }
    180 
    181 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t iid,
     176                async_answer_0(chandle, rc);
     177
     178        async_answer_0(icall_handle, rc);
     179}
     180
     181static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    182182    ipc_call_t *icall)
    183183{
    184184        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    185185
    186         cap_call_handle_t callid;
     186        cap_call_handle_t chandle;
    187187        size_t size;
    188         if (!async_data_write_receive(&callid, &size)) {
    189                 async_answer_0(callid, EREFUSED);
    190                 async_answer_0(iid, EREFUSED);
     188        if (!async_data_write_receive(&chandle, &size)) {
     189                async_answer_0(chandle, EREFUSED);
     190                async_answer_0(icall_handle, EREFUSED);
    191191                return;
    192192        }
    193193
    194194        if (size != sizeof(inet_addr_t)) {
    195                 async_answer_0(callid, EINVAL);
    196                 async_answer_0(iid, EINVAL);
     195                async_answer_0(chandle, EINVAL);
     196                async_answer_0(icall_handle, EINVAL);
    197197                return;
    198198        }
    … …  
    200200        // FIXME locking
    201201
    202         errno_t rc = async_data_write_finalize(callid, &dns_server_addr, size);
    203         if (rc != EOK) {
    204                 async_answer_0(callid, rc);
    205                 async_answer_0(iid, rc);
    206         }
    207 
    208         async_answer_0(iid, rc);
    209 }
    210 
    211 static void dnsr_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     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
     211static void dnsr_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    212212{
    213213        dnsr_client_t client;
    … …  
    216216
    217217        /* Accept the connection */
    218         async_answer_0(iid, EOK);
     218        async_answer_0(icall_handle, EOK);
    219219
    220220        while (true) {
    221221                ipc_call_t call;
    222                 cap_call_handle_t callid = async_get_call(&call);
     222                cap_call_handle_t chandle = async_get_call(&call);
    223223                sysarg_t method = IPC_GET_IMETHOD(call);
    224224
    225225                if (!method) {
    226226                        /* The other side has hung up */
    227                         async_answer_0(callid, EOK);
     227                        async_answer_0(chandle, EOK);
    228228                        return;
    229229                }
    … …  
    231231                switch (method) {
    232232                case DNSR_NAME2HOST:
    233                         dnsr_name2host_srv(&client, callid, &call);
     233                        dnsr_name2host_srv(&client, chandle, &call);
    234234                        break;
    235235                case DNSR_GET_SRVADDR:
    236                         dnsr_get_srvaddr_srv(&client, callid, &call);
     236                        dnsr_get_srvaddr_srv(&client, chandle, &call);
    237237                        break;
    238238                case DNSR_SET_SRVADDR:
    239                         dnsr_set_srvaddr_srv(&client, callid, &call);
     239                        dnsr_set_srvaddr_srv(&client, chandle, &call);
    240240                        break;
    241241                default:
    242                         async_answer_0(callid, EINVAL);
     242                        async_answer_0(chandle, EINVAL);
    243243                }
    244244        }

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

    r3e242d2 ra46e56b  
    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 iid, ipc_call_t *icall, void *arg);
     65static void ethip_client_conn(cap_call_handle_t icall_handle, 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 iid, ipc_call_t *icall, void *arg)
     144static void ethip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    145145{
    146146        ethip_nic_t *nic;
    … …  
    155155        }
    156156
    157         iplink_conn(iid, icall, &nic->iplink);
     157        iplink_conn(icall_handle, icall, &nic->iplink);
    158158}
    159159

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

    r3e242d2 ra46e56b  
    5252
    5353static errno_t ethip_nic_open(service_id_t sid);
    54 static void ethip_nic_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     54static void ethip_nic_cb_conn(cap_call_handle_t icall_handle, 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 callid,
     231static void ethip_nic_addr_changed(ethip_nic_t *nic, cap_call_handle_t chandle,
    232232    ipc_call_t *call)
    233233{
    … …  
    255255
    256256        free(addr);
    257         async_answer_0(callid, EOK);
    258 }
    259 
    260 static void ethip_nic_received(ethip_nic_t *nic, cap_call_handle_t callid,
     257        async_answer_0(chandle, EOK);
     258}
     259
     260static void ethip_nic_received(ethip_nic_t *nic, cap_call_handle_t chandle,
    261261    ipc_call_t *call)
    262262{
    … …  
    282282
    283283        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() done, rc=%s", str_error_name(rc));
    284         async_answer_0(callid, rc);
    285 }
    286 
    287 static void ethip_nic_device_state(ethip_nic_t *nic, cap_call_handle_t callid,
     284        async_answer_0(chandle, rc);
     285}
     286
     287static void ethip_nic_device_state(ethip_nic_t *nic, cap_call_handle_t chandle,
    288288    ipc_call_t *call)
    289289{
    290290        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_device_state()");
    291         async_answer_0(callid, ENOTSUP);
    292 }
    293 
    294 static void ethip_nic_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     291        async_answer_0(chandle, ENOTSUP);
     292}
     293
     294static void ethip_nic_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    295295{
    296296        ethip_nic_t *nic = (ethip_nic_t *)arg;
    … …  
    300300        while (true) {
    301301                ipc_call_t call;
    302                 cap_call_handle_t callid = async_get_call(&call);
     302                cap_call_handle_t chandle = async_get_call(&call);
    303303
    304304                if (!IPC_GET_IMETHOD(call)) {
    … …  
    309309                switch (IPC_GET_IMETHOD(call)) {
    310310                case NIC_EV_ADDR_CHANGED:
    311                         ethip_nic_addr_changed(nic, callid, &call);
     311                        ethip_nic_addr_changed(nic, chandle, &call);
    312312                        break;
    313313                case NIC_EV_RECEIVED:
    314                         ethip_nic_received(nic, callid, &call);
     314                        ethip_nic_received(nic, chandle, &call);
    315315                        break;
    316316                case NIC_EV_DEVICE_STATE:
    317                         ethip_nic_device_state(nic, callid, &call);
     317                        ethip_nic_device_state(nic, chandle, &call);
    318318                        break;
    319319                default:
    320320                        log_msg(LOG_DEFAULT, LVL_DEBUG, "unknown IPC method: %" PRIun, IPC_GET_IMETHOD(call));
    321                         async_answer_0(callid, ENOTSUP);
     321                        async_answer_0(chandle, ENOTSUP);
    322322                }
    323323        }

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

    r3e242d2 ra46e56b  
    253253}
    254254
    255 static void inetcfg_addr_create_static_srv(cap_call_handle_t iid,
     255static void inetcfg_addr_create_static_srv(cap_call_handle_t icall_handle,
    256256    ipc_call_t *icall)
    257257{
    … …  
    260260        sysarg_t link_id = IPC_GET_ARG1(*icall);
    261261
    262         cap_call_handle_t callid;
     262        cap_call_handle_t chandle;
    263263        size_t size;
    264         if (!async_data_write_receive(&callid, &size)) {
    265                 async_answer_0(callid, EINVAL);
    266                 async_answer_0(iid, EINVAL);
     264        if (!async_data_write_receive(&chandle, &size)) {
     265                async_answer_0(chandle, EINVAL);
     266                async_answer_0(icall_handle, EINVAL);
    267267                return;
    268268        }
    269269
    270270        if (size != sizeof(inet_naddr_t)) {
    271                 async_answer_0(callid, EINVAL);
    272                 async_answer_0(iid, EINVAL);
     271                async_answer_0(chandle, EINVAL);
     272                async_answer_0(icall_handle, EINVAL);
    273273                return;
    274274        }
    275275
    276276        inet_naddr_t naddr;
    277         errno_t rc = async_data_write_finalize(callid, &naddr, size);
    278         if (rc != EOK) {
    279                 async_answer_0(callid, rc);
    280                 async_answer_0(iid, rc);
     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);
    281281                return;
    282282        }
    … …  
    286286            0, NULL);
    287287        if (rc != EOK) {
    288                 async_answer_0(iid, rc);
     288                async_answer_0(icall_handle, rc);
    289289                return;
    290290        }
    … …  
    293293        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    294294        free(name);
    295         async_answer_1(iid, rc, addr_id);
    296 }
    297 
    298 static void inetcfg_addr_delete_srv(cap_call_handle_t callid, ipc_call_t *call)
     295        async_answer_1(icall_handle, rc, addr_id);
     296}
     297
     298static void inetcfg_addr_delete_srv(cap_call_handle_t chandle, ipc_call_t *call)
    299299{
    300300        sysarg_t addr_id;
    … …  
    306306
    307307        rc = inetcfg_addr_delete(addr_id);
    308         async_answer_0(callid, rc);
    309 }
    310 
    311 static void inetcfg_addr_get_srv(cap_call_handle_t iid, ipc_call_t *icall)
     308        async_answer_0(chandle, rc);
     309}
     310
     311static void inetcfg_addr_get_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    312312{
    313313        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    … …  
    323323        errno_t rc = inetcfg_addr_get(addr_id, &ainfo);
    324324        if (rc != EOK) {
    325                 async_answer_0(iid, rc);
    326                 return;
    327         }
    328 
    329         cap_call_handle_t callid;
     325                async_answer_0(icall_handle, rc);
     326                return;
     327        }
     328
     329        cap_call_handle_t chandle;
    330330        size_t size;
    331         if (!async_data_read_receive(&callid, &size)) {
    332                 async_answer_0(callid, EREFUSED);
    333                 async_answer_0(iid, EREFUSED);
     331        if (!async_data_read_receive(&chandle, &size)) {
     332                async_answer_0(chandle, EREFUSED);
     333                async_answer_0(icall_handle, EREFUSED);
    334334                return;
    335335        }
    336336
    337337        if (size != sizeof(inet_naddr_t)) {
    338                 async_answer_0(callid, EINVAL);
    339                 async_answer_0(iid, EINVAL);
    340                 return;
    341         }
    342 
    343         rc = async_data_read_finalize(callid, &ainfo.naddr, size);
    344         if (rc != EOK) {
    345                 async_answer_0(callid, rc);
    346                 async_answer_0(iid, rc);
    347                 return;
    348         }
    349 
    350         if (!async_data_read_receive(&callid, &size)) {
    351                 async_answer_0(callid, EREFUSED);
    352                 async_answer_0(iid, EREFUSED);
    353                 return;
    354         }
    355 
    356         rc = async_data_read_finalize(callid, ainfo.name,
     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,
    357357            min(size, str_size(ainfo.name)));
    358358        free(ainfo.name);
    359359
    360360        if (rc != EOK) {
    361                 async_answer_0(callid, rc);
    362                 async_answer_0(iid, rc);
    363                 return;
    364         }
    365 
    366         async_answer_1(iid, rc, ainfo.ilink);
    367 }
    368 
    369 static void inetcfg_addr_get_id_srv(cap_call_handle_t callid, ipc_call_t *call)
     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
     369static void inetcfg_addr_get_id_srv(cap_call_handle_t chandle, ipc_call_t *call)
    370370{
    371371        char *name;
    … …  
    381381            0, NULL);
    382382        if (rc != EOK) {
    383                 async_answer_0(callid, rc);
     383                async_answer_0(chandle, rc);
    384384                return;
    385385        }
    … …  
    388388        rc = inetcfg_addr_get_id(name, link_id, &addr_id);
    389389        free(name);
    390         async_answer_1(callid, rc, addr_id);
    391 }
    392 
    393 static void inetcfg_get_addr_list_srv(cap_call_handle_t callid, ipc_call_t *call)
    394 {
    395         cap_call_handle_t rcallid;
     390        async_answer_1(chandle, rc, addr_id);
     391}
     392
     393static void inetcfg_get_addr_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
     394{
     395        cap_call_handle_t rcall_handle;
    396396        size_t count;
    397397        size_t max_size;
    … …  
    403403        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    404404
    405         if (!async_data_read_receive(&rcallid, &max_size)) {
    406                 async_answer_0(rcallid, EREFUSED);
    407                 async_answer_0(callid, EREFUSED);
     405        if (!async_data_read_receive(&rcall_handle, &max_size)) {
     406                async_answer_0(rcall_handle, EREFUSED);
     407                async_answer_0(chandle, EREFUSED);
    408408                return;
    409409        }
    … …  
    411411        rc = inetcfg_get_addr_list(&id_buf, &count);
    412412        if (rc != EOK) {
    413                 async_answer_0(rcallid, rc);
    414                 async_answer_0(callid, rc);
     413                async_answer_0(rcall_handle, rc);
     414                async_answer_0(chandle, rc);
    415415                return;
    416416        }
    … …  
    419419        size = min(act_size, max_size);
    420420
    421         errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
     421        errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
    422422        free(id_buf);
    423423
    424         async_answer_1(callid, retval, act_size);
    425 }
    426 
    427 static void inetcfg_get_link_list_srv(cap_call_handle_t callid, ipc_call_t *call)
    428 {
    429         cap_call_handle_t rcallid;
     424        async_answer_1(chandle, retval, act_size);
     425}
     426
     427static void inetcfg_get_link_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
     428{
     429        cap_call_handle_t rcall_handle;
    430430        size_t count;
    431431        size_t max_size;
    … …  
    437437        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    438438
    439         if (!async_data_read_receive(&rcallid, &max_size)) {
    440                 async_answer_0(rcallid, EREFUSED);
    441                 async_answer_0(callid, EREFUSED);
     439        if (!async_data_read_receive(&rcall_handle, &max_size)) {
     440                async_answer_0(rcall_handle, EREFUSED);
     441                async_answer_0(chandle, EREFUSED);
    442442                return;
    443443        }
    … …  
    445445        rc = inetcfg_get_link_list(&id_buf, &count);
    446446        if (rc != EOK) {
    447                 async_answer_0(rcallid, rc);
    448                 async_answer_0(callid, rc);
     447                async_answer_0(rcall_handle, rc);
     448                async_answer_0(chandle, rc);
    449449                return;
    450450        }
    … …  
    453453        size = min(act_size, max_size);
    454454
    455         errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
     455        errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
    456456        free(id_buf);
    457457
    458         async_answer_1(callid, retval, act_size);
    459 }
    460 
    461 static void inetcfg_get_sroute_list_srv(cap_call_handle_t callid, ipc_call_t *call)
    462 {
    463         cap_call_handle_t rcallid;
     458        async_answer_1(chandle, retval, act_size);
     459}
     460
     461static void inetcfg_get_sroute_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
     462{
     463        cap_call_handle_t rcall_handle;
    464464        size_t count;
    465465        size_t max_size;
    … …  
    471471        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
    472472
    473         if (!async_data_read_receive(&rcallid, &max_size)) {
    474                 async_answer_0(rcallid, EREFUSED);
    475                 async_answer_0(callid, EREFUSED);
     473        if (!async_data_read_receive(&rcall_handle, &max_size)) {
     474                async_answer_0(rcall_handle, EREFUSED);
     475                async_answer_0(chandle, EREFUSED);
    476476                return;
    477477        }
    … …  
    479479        rc = inetcfg_get_sroute_list(&id_buf, &count);
    480480        if (rc != EOK) {
    481                 async_answer_0(rcallid, rc);
    482                 async_answer_0(callid, rc);
     481                async_answer_0(rcall_handle, rc);
     482                async_answer_0(chandle, rc);
    483483                return;
    484484        }
    … …  
    487487        size = min(act_size, max_size);
    488488
    489         errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
     489        errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
    490490        free(id_buf);
    491491
    492         async_answer_1(callid, retval, act_size);
    493 }
    494 
    495 static void inetcfg_link_add_srv(cap_call_handle_t callid, ipc_call_t *call)
     492        async_answer_1(chandle, retval, act_size);
     493}
     494
     495static void inetcfg_link_add_srv(cap_call_handle_t chandle, ipc_call_t *call)
    496496{
    497497        sysarg_t link_id;
    … …  
    503503
    504504        rc = inetcfg_link_add(link_id);
    505         async_answer_0(callid, rc);
    506 }
    507 
    508 static void inetcfg_link_get_srv(cap_call_handle_t callid, ipc_call_t *call)
    509 {
    510         cap_call_handle_t name_callid;
    511         cap_call_handle_t laddr_callid;
     505        async_answer_0(chandle, rc);
     506}
     507
     508static 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;
    512512        size_t name_max_size;
    513513        size_t laddr_max_size;
    … …  
    522522        linfo.name = NULL;
    523523
    524         if (!async_data_read_receive(&name_callid, &name_max_size)) {
    525                 async_answer_0(name_callid, EREFUSED);
    526                 async_answer_0(callid, EREFUSED);
    527                 return;
    528         }
    529 
    530         if (!async_data_read_receive(&laddr_callid, &laddr_max_size)) {
    531                 async_answer_0(name_callid, EREFUSED);
    532                 async_answer_0(callid, EREFUSED);
     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);
    533533                return;
    534534        }
    … …  
    536536        rc = inetcfg_link_get(link_id, &linfo);
    537537        if (rc != EOK) {
    538                 async_answer_0(laddr_callid, rc);
    539                 async_answer_0(name_callid, rc);
    540                 async_answer_0(callid, rc);
    541                 return;
    542         }
    543 
    544         errno_t retval = async_data_read_finalize(name_callid, linfo.name,
     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,
    545545            min(name_max_size, str_size(linfo.name)));
    546546        if (retval != EOK) {
    547547                free(linfo.name);
    548                 async_answer_0(laddr_callid, retval);
    549                 async_answer_0(callid, retval);
    550                 return;
    551         }
    552 
    553         retval = async_data_read_finalize(laddr_callid, &linfo.mac_addr,
     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,
    554554            min(laddr_max_size, sizeof(linfo.mac_addr)));
    555555
    556556        free(linfo.name);
    557557
    558         async_answer_1(callid, retval, linfo.def_mtu);
    559 }
    560 
    561 static void inetcfg_link_remove_srv(cap_call_handle_t callid, ipc_call_t *call)
     558        async_answer_1(chandle, retval, linfo.def_mtu);
     559}
     560
     561static void inetcfg_link_remove_srv(cap_call_handle_t chandle, ipc_call_t *call)
    562562{
    563563        sysarg_t link_id;
    … …  
    569569
    570570        rc = inetcfg_link_remove(link_id);
    571         async_answer_0(callid, rc);
    572 }
    573 
    574 static void inetcfg_sroute_create_srv(cap_call_handle_t iid,
     571        async_answer_0(chandle, rc);
     572}
     573
     574static void inetcfg_sroute_create_srv(cap_call_handle_t icall_handle,
    575575    ipc_call_t *icall)
    576576{
    577577        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
    578578
    579         cap_call_handle_t callid;
     579        cap_call_handle_t chandle;
    580580        size_t size;
    581         if (!async_data_write_receive(&callid, &size)) {
    582                 async_answer_0(callid, EINVAL);
    583                 async_answer_0(iid, EINVAL);
     581        if (!async_data_write_receive(&chandle, &size)) {
     582                async_answer_0(chandle, EINVAL);
     583                async_answer_0(icall_handle, EINVAL);
    584584                return;
    585585        }
    586586
    587587        if (size != sizeof(inet_naddr_t)) {
    588                 async_answer_0(callid, EINVAL);
    589                 async_answer_0(iid, EINVAL);
     588                async_answer_0(chandle, EINVAL);
     589                async_answer_0(icall_handle, EINVAL);
    590590                return;
    591591        }
    592592
    593593        inet_naddr_t dest;
    594         errno_t rc = async_data_write_finalize(callid, &dest, size);
    595         if (rc != EOK) {
    596                 async_answer_0(callid, rc);
    597                 async_answer_0(iid, rc);
    598                 return;
    599         }
    600 
    601         if (!async_data_write_receive(&callid, &size)) {
    602                 async_answer_0(callid, EINVAL);
    603                 async_answer_0(iid, EINVAL);
     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);
    604604                return;
    605605        }
    606606
    607607        if (size != sizeof(inet_addr_t)) {
    608                 async_answer_0(callid, EINVAL);
    609                 async_answer_0(iid, EINVAL);
     608                async_answer_0(chandle, EINVAL);
     609                async_answer_0(icall_handle, EINVAL);
    610610                return;
    611611        }
    612612
    613613        inet_addr_t router;
    614         rc = async_data_write_finalize(callid, &router, size);
    615         if (rc != EOK) {
    616                 async_answer_0(callid, rc);
    617                 async_answer_0(iid, rc);
     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);
    618618                return;
    619619        }
    … …  
    623623            0, NULL);
    624624        if (rc != EOK) {
    625                 async_answer_0(iid, rc);
     625                async_answer_0(icall_handle, rc);
    626626                return;
    627627        }
    … …  
    630630        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    631631        free(name);
    632         async_answer_1(iid, rc, sroute_id);
    633 }
    634 
    635 static void inetcfg_sroute_delete_srv(cap_call_handle_t callid, ipc_call_t *call)
     632        async_answer_1(icall_handle, rc, sroute_id);
     633}
     634
     635static void inetcfg_sroute_delete_srv(cap_call_handle_t chandle, ipc_call_t *call)
    636636{
    637637        sysarg_t sroute_id;
    … …  
    643643
    644644        rc = inetcfg_sroute_delete(sroute_id);
    645         async_answer_0(callid, rc);
    646 }
    647 
    648 static void inetcfg_sroute_get_srv(cap_call_handle_t iid, ipc_call_t *icall)
     645        async_answer_0(chandle, rc);
     646}
     647
     648static void inetcfg_sroute_get_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    649649{
    650650        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    … …  
    660660        errno_t rc = inetcfg_sroute_get(sroute_id, &srinfo);
    661661        if (rc != EOK) {
    662                 async_answer_0(iid, rc);
    663                 return;
    664         }
    665 
    666         cap_call_handle_t callid;
     662                async_answer_0(icall_handle, rc);
     663                return;
     664        }
     665
     666        cap_call_handle_t chandle;
    667667        size_t size;
    668         if (!async_data_read_receive(&callid, &size)) {
    669                 async_answer_0(callid, EREFUSED);
    670                 async_answer_0(iid, EREFUSED);
     668        if (!async_data_read_receive(&chandle, &size)) {
     669                async_answer_0(chandle, EREFUSED);
     670                async_answer_0(icall_handle, EREFUSED);
    671671                return;
    672672        }
    673673
    674674        if (size != sizeof(inet_naddr_t)) {
    675                 async_answer_0(callid, EINVAL);
    676                 async_answer_0(iid, EINVAL);
    677                 return;
    678         }
    679 
    680         rc = async_data_read_finalize(callid, &srinfo.dest, size);
    681         if (rc != EOK) {
    682                 async_answer_0(callid, rc);
    683                 async_answer_0(iid, rc);
    684                 return;
    685         }
    686 
    687         if (!async_data_read_receive(&callid, &size)) {
    688                 async_answer_0(callid, EREFUSED);
    689                 async_answer_0(iid, EREFUSED);
     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);
    690690                return;
    691691        }
    692692
    693693        if (size != sizeof(inet_addr_t)) {
    694                 async_answer_0(callid, EINVAL);
    695                 async_answer_0(iid, EINVAL);
    696                 return;
    697         }
    698 
    699         rc = async_data_read_finalize(callid, &srinfo.router, size);
    700         if (rc != EOK) {
    701                 async_answer_0(callid, rc);
    702                 async_answer_0(iid, rc);
    703                 return;
    704         }
    705 
    706         if (!async_data_read_receive(&callid, &size)) {
    707                 async_answer_0(callid, EREFUSED);
    708                 async_answer_0(iid, EREFUSED);
    709                 return;
    710         }
    711 
    712         rc = async_data_read_finalize(callid, srinfo.name,
     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,
    713713            min(size, str_size(srinfo.name)));
    714714        free(srinfo.name);
    715715
    716         async_answer_0(iid, rc);
    717 }
    718 
    719 static void inetcfg_sroute_get_id_srv(cap_call_handle_t callid, ipc_call_t *call)
     716        async_answer_0(icall_handle, rc);
     717}
     718
     719static void inetcfg_sroute_get_id_srv(cap_call_handle_t chandle, ipc_call_t *call)
    720720{
    721721        char *name;
    … …  
    728728            0, NULL);
    729729        if (rc != EOK) {
    730                 async_answer_0(callid, rc);
     730                async_answer_0(chandle, rc);
    731731                return;
    732732        }
    … …  
    735735        rc = inetcfg_sroute_get_id(name, &sroute_id);
    736736        free(name);
    737         async_answer_1(callid, rc, sroute_id);
    738 }
    739 
    740 void inet_cfg_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     737        async_answer_1(chandle, rc, sroute_id);
     738}
     739
     740void inet_cfg_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    741741{
    742742        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_cfg_conn()");
    743743
    744744        /* Accept the connection */
    745         async_answer_0(iid, EOK);
     745        async_answer_0(icall_handle, EOK);
    746746
    747747        while (true) {
    748748                ipc_call_t call;
    749                 cap_call_handle_t callid = async_get_call(&call);
     749                cap_call_handle_t chandle = async_get_call(&call);
    750750                sysarg_t method = IPC_GET_IMETHOD(call);
    751751
    … …  
    753753                if (!method) {
    754754                        /* The other side has hung up */
    755                         async_answer_0(callid, EOK);
     755                        async_answer_0(chandle, EOK);
    756756                        return;
    757757                }
    … …  
    759759                switch (method) {
    760760                case INETCFG_ADDR_CREATE_STATIC:
    761                         inetcfg_addr_create_static_srv(callid, &call);
     761                        inetcfg_addr_create_static_srv(chandle, &call);
    762762                        break;
    763763                case INETCFG_ADDR_DELETE:
    764                         inetcfg_addr_delete_srv(callid, &call);
     764                        inetcfg_addr_delete_srv(chandle, &call);
    765765                        break;
    766766                case INETCFG_ADDR_GET:
    767                         inetcfg_addr_get_srv(callid, &call);
     767                        inetcfg_addr_get_srv(chandle, &call);
    768768                        break;
    769769                case INETCFG_ADDR_GET_ID:
    770                         inetcfg_addr_get_id_srv(callid, &call);
     770                        inetcfg_addr_get_id_srv(chandle, &call);
    771771                        break;
    772772                case INETCFG_GET_ADDR_LIST:
    773                         inetcfg_get_addr_list_srv(callid, &call);
     773                        inetcfg_get_addr_list_srv(chandle, &call);
    774774                        break;
    775775                case INETCFG_GET_LINK_LIST:
    776                         inetcfg_get_link_list_srv(callid, &call);
     776                        inetcfg_get_link_list_srv(chandle, &call);
    777777                        break;
    778778                case INETCFG_GET_SROUTE_LIST:
    779                         inetcfg_get_sroute_list_srv(callid, &call);
     779                        inetcfg_get_sroute_list_srv(chandle, &call);
    780780                        break;
    781781                case INETCFG_LINK_ADD:
    782                         inetcfg_link_add_srv(callid, &call);
     782                        inetcfg_link_add_srv(chandle, &call);
    783783                        break;
    784784                case INETCFG_LINK_GET:
    785                         inetcfg_link_get_srv(callid, &call);
     785                        inetcfg_link_get_srv(chandle, &call);
    786786                        break;
    787787                case INETCFG_LINK_REMOVE:
    788                         inetcfg_link_remove_srv(callid, &call);
     788                        inetcfg_link_remove_srv(chandle, &call);
    789789                        break;
    790790                case INETCFG_SROUTE_CREATE:
    791                         inetcfg_sroute_create_srv(callid, &call);
     791                        inetcfg_sroute_create_srv(chandle, &call);
    792792                        break;
    793793                case INETCFG_SROUTE_DELETE:
    794                         inetcfg_sroute_delete_srv(callid, &call);
     794                        inetcfg_sroute_delete_srv(chandle, &call);
    795795                        break;
    796796                case INETCFG_SROUTE_GET:
    797                         inetcfg_sroute_get_srv(callid, &call);
     797                        inetcfg_sroute_get_srv(chandle, &call);
    798798                        break;
    799799                case INETCFG_SROUTE_GET_ID:
    800                         inetcfg_sroute_get_id_srv(callid, &call);
     800                        inetcfg_sroute_get_id_srv(chandle, &call);
    801801                        break;
    802802                default:
    803                         async_answer_0(callid, EINVAL);
     803                        async_answer_0(chandle, EINVAL);
    804804                }
    805805        }

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

    r3e242d2 ra46e56b  
    136136}
    137137
    138 static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t iid,
     138static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t icall_handle,
    139139    ipc_call_t *icall)
    140140{
    … …  
    146146        sdu.seq_no = IPC_GET_ARG1(*icall);
    147147
    148         cap_call_handle_t callid;
     148        cap_call_handle_t chandle;
    149149        size_t size;
    150         if (!async_data_write_receive(&callid, &size)) {
    151                 async_answer_0(callid, EREFUSED);
    152                 async_answer_0(iid, EREFUSED);
     150        if (!async_data_write_receive(&chandle, &size)) {
     151                async_answer_0(chandle, EREFUSED);
     152                async_answer_0(icall_handle, EREFUSED);
    153153                return;
    154154        }
    155155
    156156        if (size != sizeof(sdu.src)) {
    157                 async_answer_0(callid, EINVAL);
    158                 async_answer_0(iid, EINVAL);
    159                 return;
    160         }
    161 
    162         rc = async_data_write_finalize(callid, &sdu.src, size);
    163         if (rc != EOK) {
    164                 async_answer_0(callid, rc);
    165                 async_answer_0(iid, rc);
    166                 return;
    167         }
    168 
    169         if (!async_data_write_receive(&callid, &size)) {
    170                 async_answer_0(callid, EREFUSED);
    171                 async_answer_0(iid, EREFUSED);
     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);
    172172                return;
    173173        }
    174174
    175175        if (size != sizeof(sdu.dest)) {
    176                 async_answer_0(callid, EINVAL);
    177                 async_answer_0(iid, EINVAL);
    178                 return;
    179         }
    180 
    181         rc = async_data_write_finalize(callid, &sdu.dest, size);
    182         if (rc != EOK) {
    183                 async_answer_0(callid, rc);
    184                 async_answer_0(iid, rc);
     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);
    185185                return;
    186186        }
    … …  
    189189            &sdu.size);
    190190        if (rc != EOK) {
    191                 async_answer_0(iid, rc);
     191                async_answer_0(icall_handle, rc);
    192192                return;
    193193        }
    … …  
    196196        free(sdu.data);
    197197
    198         async_answer_0(iid, rc);
     198        async_answer_0(icall_handle, rc);
    199199}
    200200
    201201static void inetping_get_srcaddr_srv(inetping_client_t *client,
    202     cap_call_handle_t iid, ipc_call_t *icall)
     202    cap_call_handle_t icall_handle, ipc_call_t *icall)
    203203{
    204204        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    205205
    206         cap_call_handle_t callid;
     206        cap_call_handle_t chandle;
    207207        size_t size;
    208208
    … …  
    210210        inet_addr_t remote;
    211211
    212         if (!async_data_write_receive(&callid, &size)) {
    213                 async_answer_0(callid, EREFUSED);
    214                 async_answer_0(iid, EREFUSED);
     212        if (!async_data_write_receive(&chandle, &size)) {
     213                async_answer_0(chandle, EREFUSED);
     214                async_answer_0(icall_handle, EREFUSED);
    215215                return;
    216216        }
    217217
    218218        if (size != sizeof(remote)) {
    219                 async_answer_0(callid, EINVAL);
    220                 async_answer_0(iid, EINVAL);
    221                 return;
    222         }
    223 
    224         errno_t rc = async_data_write_finalize(callid, &remote, size);
    225         if (rc != EOK) {
    226                 async_answer_0(callid, rc);
    227                 async_answer_0(iid, rc);
     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);
    228228                return;
    229229        }
    … …  
    231231        rc = inetping_get_srcaddr(client, &remote, &local);
    232232        if (rc != EOK) {
    233                 async_answer_0(iid, rc);
    234                 return;
    235         }
    236 
    237         if (!async_data_read_receive(&callid, &size)) {
    238                 async_answer_0(callid, EREFUSED);
    239                 async_answer_0(iid, EREFUSED);
     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);
    240240                return;
    241241        }
    242242
    243243        if (size != sizeof(local)) {
    244                 async_answer_0(callid, EINVAL);
    245                 async_answer_0(iid, EINVAL);
    246                 return;
    247         }
    248 
    249         rc = async_data_read_finalize(callid, &local, size);
     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);
    250250        if (rc != EOK)
    251                 async_answer_0(callid, rc);
    252 
    253         async_answer_0(iid, rc);
     251                async_answer_0(chandle, rc);
     252
     253        async_answer_0(icall_handle, rc);
    254254}
    255255
    … …  
    281281}
    282282
    283 void inetping_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     283void inetping_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    284284{
    285285        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    286286
    287287        /* Accept the connection */
    288         async_answer_0(iid, EOK);
     288        async_answer_0(icall_handle, EOK);
    289289
    290290        inetping_client_t client;
    … …  
    295295        while (true) {
    296296                ipc_call_t call;
    297                 cap_call_handle_t callid = async_get_call(&call);
     297                cap_call_handle_t chandle = async_get_call(&call);
    298298                sysarg_t method = IPC_GET_IMETHOD(call);
    299299
    300300                if (!method) {
    301301                        /* The other side has hung up */
    302                         async_answer_0(callid, EOK);
     302                        async_answer_0(chandle, EOK);
    303303                        break;
    304304                }
    … …  
    306306                switch (method) {
    307307                case INETPING_SEND:
    308                         inetping_send_srv(&client, callid, &call);
     308                        inetping_send_srv(&client, chandle, &call);
    309309                        break;
    310310                case INETPING_GET_SRCADDR:
    311                         inetping_get_srcaddr_srv(&client, callid, &call);
     311                        inetping_get_srcaddr_srv(&client, chandle, &call);
    312312                        break;
    313313                default:
    314                         async_answer_0(callid, EINVAL);
     314                        async_answer_0(chandle, EINVAL);
    315315                }
    316316        }

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

    r3e242d2 ra46e56b  
    120120}
    121121
    122 static void inet_callback_create_srv(inet_client_t *client, cap_call_handle_t callid,
     122static void inet_callback_create_srv(inet_client_t *client, cap_call_handle_t chandle,
    123123    ipc_call_t *call)
    124124{
    … …  
    127127        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    128128        if (sess == NULL) {
    129                 async_answer_0(callid, ENOMEM);
     129                async_answer_0(chandle, ENOMEM);
    130130                return;
    131131        }
    132132
    133133        client->sess = sess;
    134         async_answer_0(callid, EOK);
     134        async_answer_0(chandle, EOK);
    135135}
    136136
    … …  
    230230}
    231231
    232 static void inet_get_srcaddr_srv(inet_client_t *client, cap_call_handle_t iid,
     232static void inet_get_srcaddr_srv(inet_client_t *client, cap_call_handle_t icall_handle,
    233233    ipc_call_t *icall)
    234234{
    … …  
    237237        uint8_t tos = IPC_GET_ARG1(*icall);
    238238
    239         cap_call_handle_t callid;
     239        cap_call_handle_t chandle;
    240240        size_t size;
    241         if (!async_data_write_receive(&callid, &size)) {
    242                 async_answer_0(callid, EREFUSED);
    243                 async_answer_0(iid, EREFUSED);
     241        if (!async_data_write_receive(&chandle, &size)) {
     242                async_answer_0(chandle, EREFUSED);
     243                async_answer_0(icall_handle, EREFUSED);
    244244                return;
    245245        }
    246246
    247247        if (size != sizeof(inet_addr_t)) {
    248                 async_answer_0(callid, EINVAL);
    249                 async_answer_0(iid, EINVAL);
     248                async_answer_0(chandle, EINVAL);
     249                async_answer_0(icall_handle, EINVAL);
    250250                return;
    251251        }
    252252
    253253        inet_addr_t remote;
    254         errno_t rc = async_data_write_finalize(callid, &remote, size);
    255         if (rc != EOK) {
    256                 async_answer_0(callid, rc);
    257                 async_answer_0(iid, rc);
     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);
    258258        }
    259259
    … …  
    261261        rc = inet_get_srcaddr(&remote, tos, &local);
    262262        if (rc != EOK) {
    263                 async_answer_0(iid, rc);
    264                 return;
    265         }
    266 
    267         if (!async_data_read_receive(&callid, &size)) {
    268                 async_answer_0(callid, EREFUSED);
    269                 async_answer_0(iid, EREFUSED);
     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);
    270270                return;
    271271        }
    272272
    273273        if (size != sizeof(inet_addr_t)) {
    274                 async_answer_0(callid, EINVAL);
    275                 async_answer_0(iid, EINVAL);
    276                 return;
    277         }
    278 
    279         rc = async_data_read_finalize(callid, &local, size);
    280         if (rc != EOK) {
    281                 async_answer_0(callid, rc);
    282                 async_answer_0(iid, rc);
    283                 return;
    284         }
    285 
    286         async_answer_0(iid, rc);
    287 }
    288 
    289 static void inet_send_srv(inet_client_t *client, cap_call_handle_t iid,
     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
     289static void inet_send_srv(inet_client_t *client, cap_call_handle_t icall_handle,
    290290    ipc_call_t *icall)
    291291{
    … …  
    300300        int df = IPC_GET_ARG4(*icall);
    301301
    302         cap_call_handle_t callid;
     302        cap_call_handle_t chandle;
    303303        size_t size;
    304         if (!async_data_write_receive(&callid, &size)) {
    305                 async_answer_0(callid, EREFUSED);
    306                 async_answer_0(iid, EREFUSED);
     304        if (!async_data_write_receive(&chandle, &size)) {
     305                async_answer_0(chandle, EREFUSED);
     306                async_answer_0(icall_handle, EREFUSED);
    307307                return;
    308308        }
    309309
    310310        if (size != sizeof(inet_addr_t)) {
    311                 async_answer_0(callid, EINVAL);
    312                 async_answer_0(iid, EINVAL);
    313                 return;
    314         }
    315 
    316         errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
    317         if (rc != EOK) {
    318                 async_answer_0(callid, rc);
    319                 async_answer_0(iid, rc);
    320         }
    321 
    322         if (!async_data_write_receive(&callid, &size)) {
    323                 async_answer_0(callid, EREFUSED);
    324                 async_answer_0(iid, EREFUSED);
     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);
    325325                return;
    326326        }
    327327
    328328        if (size != sizeof(inet_addr_t)) {
    329                 async_answer_0(callid, EINVAL);
    330                 async_answer_0(iid, EINVAL);
    331                 return;
    332         }
    333 
    334         rc = async_data_write_finalize(callid, &dgram.dest, size);
    335         if (rc != EOK) {
    336                 async_answer_0(callid, rc);
    337                 async_answer_0(iid, rc);
     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);
    338338        }
    339339
    … …  
    341341            &dgram.size);
    342342        if (rc != EOK) {
    343                 async_answer_0(iid, rc);
     343                async_answer_0(icall_handle, rc);
    344344                return;
    345345        }
    … …  
    348348
    349349        free(dgram.data);
    350         async_answer_0(iid, rc);
    351 }
    352 
    353 static void inet_set_proto_srv(inet_client_t *client, cap_call_handle_t callid,
     350        async_answer_0(icall_handle, rc);
     351}
     352
     353static void inet_set_proto_srv(inet_client_t *client, cap_call_handle_t chandle,
    354354    ipc_call_t *call)
    355355{
    … …  
    360360
    361361        if (proto > UINT8_MAX) {
    362                 async_answer_0(callid, EINVAL);
     362                async_answer_0(chandle, EINVAL);
    363363                return;
    364364        }
    365365
    366366        client->protocol = proto;
    367         async_answer_0(callid, EOK);
     367        async_answer_0(chandle, EOK);
    368368}
    369369
    … …  
    387387}
    388388
    389 static void inet_default_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     389static void inet_default_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    390390{
    391391        inet_client_t client;
    … …  
    394394
    395395        /* Accept the connection */
    396         async_answer_0(iid, EOK);
     396        async_answer_0(icall_handle, EOK);
    397397
    398398        inet_client_init(&client);
    … …  
    400400        while (true) {
    401401                ipc_call_t call;
    402                 cap_call_handle_t callid = async_get_call(&call);
     402                cap_call_handle_t chandle = async_get_call(&call);
    403403                sysarg_t method = IPC_GET_IMETHOD(call);
    404404
    405405                if (!method) {
    406406                        /* The other side has hung up */
    407                         async_answer_0(callid, EOK);
     407                        async_answer_0(chandle, EOK);
    408408                        return;
    409409                }
    … …  
    411411                switch (method) {
    412412                case INET_CALLBACK_CREATE:
    413                         inet_callback_create_srv(&client, callid, &call);
     413                        inet_callback_create_srv(&client, chandle, &call);
    414414                        break;
    415415                case INET_GET_SRCADDR:
    416                         inet_get_srcaddr_srv(&client, callid, &call);
     416                        inet_get_srcaddr_srv(&client, chandle, &call);
    417417                        break;
    418418                case INET_SEND:
    419                         inet_send_srv(&client, callid, &call);
     419                        inet_send_srv(&client, chandle, &call);
    420420                        break;
    421421                case INET_SET_PROTO:
    422                         inet_set_proto_srv(&client, callid, &call);
     422                        inet_set_proto_srv(&client, chandle, &call);
    423423                        break;
    424424                default:
    425                         async_answer_0(callid, EINVAL);
     425                        async_answer_0(chandle, EINVAL);
    426426                }
    427427        }

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

    r3e242d2 ra46e56b  
    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 iid, ipc_call_t *icall, void *arg);
     61static void loopip_client_conn(cap_call_handle_t icall_handle, 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 iid, ipc_call_t *icall, void *arg)
     150static void loopip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    151151{
    152152        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_client_conn()");
    153         iplink_conn(iid, icall, &loopip_iplink);
     153        iplink_conn(icall_handle, icall, &loopip_iplink);
    154154}
    155155

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

    r3e242d2 ra46e56b  
    5454#define NAME "nconfsrv"
    5555
    56 static void ncs_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     56static void ncs_client_conn(cap_call_handle_t icall_handle, 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 iid, ipc_call_t *icall, void *arg)
     100static void ncs_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    101101{
    102         async_answer_0(iid, ENOTSUP);
     102        async_answer_0(icall_handle, ENOTSUP);
    103103}
    104104

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

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

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

    r3e242d2 ra46e56b  
    724724 * Handle client request to create callback session.
    725725 *
    726  * @param client  TCP client
    727  * @param iid     Async request ID
    728  * @param icall   Async request data
    729  */
    730 static void tcp_callback_create_srv(tcp_client_t *client, cap_call_handle_t iid,
    731     ipc_call_t *icall)
     726 * @param client        TCP client
     727 * @param icall_handle  Async request call handle
     728 * @param icall         Async request data
     729 */
     730static void tcp_callback_create_srv(tcp_client_t *client,
     731    cap_call_handle_t icall_handle, ipc_call_t *icall)
    732732{
    733733        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_callback_create_srv()");
    … …  
    735735        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    736736        if (sess == NULL) {
    737                 async_answer_0(iid, ENOMEM);
     737                async_answer_0(icall_handle, ENOMEM);
    738738                return;
    739739        }
    740740
    741741        client->sess = sess;
    742         async_answer_0(iid, EOK);
     742        async_answer_0(icall_handle, EOK);
    743743}
    744744
    … …  
    747747 * Handle client request to create connection.
    748748 *
    749  * @param client   TCP client
    750  * @param iid      Async request ID
    751  * @param icall    Async request data
    752  */
    753 static void tcp_conn_create_srv(tcp_client_t *client, cap_call_handle_t iid,
    754     ipc_call_t *icall)
    755 {
    756         cap_call_handle_t callid;
     749 * @param client        TCP client
     750 * @param icall_handle  Async request call handle
     751 * @param icall         Async request data
     752 */
     753static void tcp_conn_create_srv(tcp_client_t *client,
     754    cap_call_handle_t icall_handle, ipc_call_t *icall)
     755{
     756        cap_call_handle_t chandle;
    757757        size_t size;
    758758        inet_ep2_t epp;
    … …  
    762762        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
    763763
    764         if (!async_data_write_receive(&callid, &size)) {
    765                 async_answer_0(callid, EREFUSED);
    766                 async_answer_0(iid, EREFUSED);
     764        if (!async_data_write_receive(&chandle, &size)) {
     765                async_answer_0(chandle, EREFUSED);
     766                async_answer_0(icall_handle, EREFUSED);
    767767                return;
    768768        }
    769769
    770770        if (size != sizeof(inet_ep2_t)) {
    771                 async_answer_0(callid, EINVAL);
    772                 async_answer_0(iid, EINVAL);
    773                 return;
    774         }
    775 
    776         rc = async_data_write_finalize(callid, &epp, size);
    777         if (rc != EOK) {
    778                 async_answer_0(callid, rc);
    779                 async_answer_0(iid, rc);
     771                async_answer_0(chandle, EINVAL);
     772                async_answer_0(icall_handle, EINVAL);
     773                return;
     774        }
     775
     776        rc = async_data_write_finalize(chandle, &epp, size);
     777        if (rc != EOK) {
     778                async_answer_0(chandle, rc);
     779                async_answer_0(icall_handle, rc);
    780780                return;
    781781        }
    … …  
    783783        rc = tcp_conn_create_impl(client, &epp, &conn_id);
    784784        if (rc != EOK) {
    785                 async_answer_0(iid, rc);
    786                 return;
    787         }
    788 
    789         async_answer_1(iid, EOK, conn_id);
     785                async_answer_0(icall_handle, rc);
     786                return;
     787        }
     788
     789        async_answer_1(icall_handle, EOK, conn_id);
    790790}
    791791
    … …  
    794794 * Handle client request to destroy connection.
    795795 *
    796  * @param client   TCP client
    797  * @param iid      Async request ID
    798  * @param icall    Async request data
    799  */
    800 static void tcp_conn_destroy_srv(tcp_client_t *client, cap_call_handle_t iid,
    801     ipc_call_t *icall)
     796 * @param client        TCP client
     797 * @param icall_handle  Async request call handle
     798 * @param icall         Async request data
     799 */
     800static void tcp_conn_destroy_srv(tcp_client_t *client,
     801    cap_call_handle_t icall_handle, ipc_call_t *icall)
    802802{
    803803        sysarg_t conn_id;
    … …  
    808808        conn_id = IPC_GET_ARG1(*icall);
    809809        rc = tcp_conn_destroy_impl(client, conn_id);
    810         async_answer_0(iid, rc);
     810        async_answer_0(icall_handle, rc);
    811811}
    812812
    … …  
    815815 * Handle client request to create listener.
    816816 *
    817  * @param client   TCP client
    818  * @param iid      Async request ID
    819  * @param icall    Async request data
    820  */
    821 static void tcp_listener_create_srv(tcp_client_t *client, cap_call_handle_t iid,
    822     ipc_call_t *icall)
    823 {
    824         cap_call_handle_t callid;
     817 * @param client        TCP client
     818 * @param icall_handle  Async request call handle
     819 * @param icall         Async request data
     820 */
     821static void tcp_listener_create_srv(tcp_client_t *client,
     822    cap_call_handle_t icall_handle, ipc_call_t *icall)
     823{
     824        cap_call_handle_t chandle;
    825825        size_t size;
    826826        inet_ep_t ep;
    … …  
    830830        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
    831831
    832         if (!async_data_write_receive(&callid, &size)) {
    833                 async_answer_0(callid, EREFUSED);
    834                 async_answer_0(iid, EREFUSED);
     832        if (!async_data_write_receive(&chandle, &size)) {
     833                async_answer_0(chandle, EREFUSED);
     834                async_answer_0(icall_handle, EREFUSED);
    835835                return;
    836836        }
    837837
    838838        if (size != sizeof(inet_ep_t)) {
    839                 async_answer_0(callid, EINVAL);
    840                 async_answer_0(iid, EINVAL);
    841                 return;
    842         }
    843 
    844         rc = async_data_write_finalize(callid, &ep, size);
    845         if (rc != EOK) {
    846                 async_answer_0(callid, rc);
    847                 async_answer_0(iid, rc);
     839                async_answer_0(chandle, EINVAL);
     840                async_answer_0(icall_handle, EINVAL);
     841                return;
     842        }
     843
     844        rc = async_data_write_finalize(chandle, &ep, size);
     845        if (rc != EOK) {
     846                async_answer_0(chandle, rc);
     847                async_answer_0(icall_handle, rc);
    848848                return;
    849849        }
    … …  
    851851        rc = tcp_listener_create_impl(client, &ep, &lst_id);
    852852        if (rc != EOK) {
    853                 async_answer_0(iid, rc);
    854                 return;
    855         }
    856 
    857         async_answer_1(iid, EOK, lst_id);
     853                async_answer_0(icall_handle, rc);
     854                return;
     855        }
     856
     857        async_answer_1(icall_handle, EOK, lst_id);
    858858}
    859859
    … …  
    862862 * Handle client request to destroy listener.
    863863 *
    864  * @param client   TCP client
    865  * @param iid      Async request ID
    866  * @param icall    Async request data
    867  */
    868 static void tcp_listener_destroy_srv(tcp_client_t *client, cap_call_handle_t iid,
    869     ipc_call_t *icall)
     864 * @param client        TCP client
     865 * @param icall_handle  Async request call handle
     866 * @param icall         Async request data
     867 */
     868static void tcp_listener_destroy_srv(tcp_client_t *client,
     869    cap_call_handle_t icall_handle, ipc_call_t *icall)
    870870{
    871871        sysarg_t lst_id;
    … …  
    876876        lst_id = IPC_GET_ARG1(*icall);
    877877        rc = tcp_listener_destroy_impl(client, lst_id);
    878         async_answer_0(iid, rc);
     878        async_answer_0(icall_handle, rc);
    879879}
    880880
    … …  
    883883 * Handle client request to send FIN.
    884884 *
    885  * @param client   TCP client
    886  * @param iid      Async request ID
    887  * @param icall    Async request data
    888  */
    889 static void tcp_conn_send_fin_srv(tcp_client_t *client, cap_call_handle_t iid,
    890     ipc_call_t *icall)
     885 * @param client        TCP client
     886 * @param icall_handle  Async request call handle
     887 * @param icall         Async request data
     888 */
     889static void tcp_conn_send_fin_srv(tcp_client_t *client,
     890    cap_call_handle_t icall_handle, ipc_call_t *icall)
    891891{
    892892        sysarg_t conn_id;
    … …  
    897897        conn_id = IPC_GET_ARG1(*icall);
    898898        rc = tcp_conn_send_fin_impl(client, conn_id);
    899         async_answer_0(iid, rc);
     899        async_answer_0(icall_handle, rc);
    900900}
    901901
    … …  
    904904 * Handle client request to push connection.
    905905 *
    906  * @param client   TCP client
    907  * @param iid      Async request ID
    908  * @param icall    Async request data
    909  */
    910 static void tcp_conn_push_srv(tcp_client_t *client, cap_call_handle_t iid,
    911     ipc_call_t *icall)
     906 * @param client        TCP client
     907 * @param icall_handle  Async request call handle
     908 * @param icall         Async request data
     909 */
     910static void tcp_conn_push_srv(tcp_client_t *client,
     911    cap_call_handle_t icall_handle, ipc_call_t *icall)
    912912{
    913913        sysarg_t conn_id;
    … …  
    918918        conn_id = IPC_GET_ARG1(*icall);
    919919        rc = tcp_conn_push_impl(client, conn_id);
    920         async_answer_0(iid, rc);
     920        async_answer_0(icall_handle, rc);
    921921}
    922922
    … …  
    925925 * Handle client request to reset connection.
    926926 *
    927  * @param client   TCP client
    928  * @param iid      Async request ID
    929  * @param icall    Async request data
    930  */
    931 static void tcp_conn_reset_srv(tcp_client_t *client, cap_call_handle_t iid,
    932     ipc_call_t *icall)
     927 * @param client        TCP client
     928 * @param icall_handle  Async request call handle
     929 * @param icall         Async request data
     930 */
     931static void tcp_conn_reset_srv(tcp_client_t *client,
     932    cap_call_handle_t icall_handle, ipc_call_t *icall)
    933933{
    934934        sysarg_t conn_id;
    … …  
    939939        conn_id = IPC_GET_ARG1(*icall);
    940940        rc = tcp_conn_reset_impl(client, conn_id);
    941         async_answer_0(iid, rc);
     941        async_answer_0(icall_handle, rc);
    942942}
    943943
    … …  
    946946 * Handle client request to send data via connection.
    947947 *
    948  * @param client   TCP client
    949  * @param iid      Async request ID
    950  * @param icall    Async request data
    951  */
    952 static void tcp_conn_send_srv(tcp_client_t *client, cap_call_handle_t iid,
    953     ipc_call_t *icall)
    954 {
    955         cap_call_handle_t callid;
     948 * @param client        TCP client
     949 * @param icall_handle  Async request call handle
     950 * @param icall         Async request data
     951 */
     952static void tcp_conn_send_srv(tcp_client_t *client,
     953    cap_call_handle_t icall_handle, ipc_call_t *icall)
     954{
     955        cap_call_handle_t chandle;
    956956        size_t size;
    957957        sysarg_t conn_id;
    … …  
    963963        /* Receive message data */
    964964
    965         if (!async_data_write_receive(&callid, &size)) {
    966                 async_answer_0(callid, EREFUSED);
    967                 async_answer_0(iid, EREFUSED);
     965        if (!async_data_write_receive(&chandle, &size)) {
     966                async_answer_0(chandle, EREFUSED);
     967                async_answer_0(icall_handle, EREFUSED);
    968968                return;
    969969        }
    970970
    971971        if (size > MAX_MSG_SIZE) {
    972                 async_answer_0(callid, EINVAL);
    973                 async_answer_0(iid, EINVAL);
     972                async_answer_0(chandle, EINVAL);
     973                async_answer_0(icall_handle, EINVAL);
    974974                return;
    975975        }
    … …  
    977977        data = malloc(size);
    978978        if (data == NULL) {
    979                 async_answer_0(callid, ENOMEM);
    980                 async_answer_0(iid, ENOMEM);
    981                 return;
    982         }
    983 
    984         rc = async_data_write_finalize(callid, data, size);
    985         if (rc != EOK) {
    986                 async_answer_0(callid, rc);
    987                 async_answer_0(iid, rc);
     979                async_answer_0(chandle, ENOMEM);
     980                async_answer_0(icall_handle, ENOMEM);
     981                return;
     982        }
     983
     984        rc = async_data_write_finalize(chandle, data, size);
     985        if (rc != EOK) {
     986                async_answer_0(chandle, rc);
     987                async_answer_0(icall_handle, rc);
    988988                free(data);
    989989                return;
    … …  
    994994        rc = tcp_conn_send_impl(client, conn_id, data, size);
    995995        if (rc != EOK) {
    996                 async_answer_0(iid, rc);
     996                async_answer_0(icall_handle, rc);
    997997                free(data);
    998998                return;
    999999        }
    10001000
    1001         async_answer_0(iid, EOK);
     1001        async_answer_0(icall_handle, EOK);
    10021002        free(data);
    10031003}
    … …  
    10071007 * Handle client request to read received data via connection without blocking.
    10081008 *
    1009  * @param client   TCP client
    1010  * @param iid      Async request ID
    1011  * @param icall    Async request data
    1012  */
    1013 static void tcp_conn_recv_srv(tcp_client_t *client, cap_call_handle_t iid,
    1014     ipc_call_t *icall)
    1015 {
    1016         cap_call_handle_t callid;
     1009 * @param client        TCP client
     1010 * @param icall_handle  Async request call handle
     1011 * @param icall         Async request data
     1012 */
     1013static void tcp_conn_recv_srv(tcp_client_t *client,
     1014    cap_call_handle_t icall_handle, ipc_call_t *icall)
     1015{
     1016        cap_call_handle_t chandle;
    10171017        sysarg_t conn_id;
    10181018        size_t size, rsize;
    … …  
    10241024        conn_id = IPC_GET_ARG1(*icall);
    10251025
    1026         if (!async_data_read_receive(&callid, &size)) {
    1027                 async_answer_0(callid, EREFUSED);
    1028                 async_answer_0(iid, EREFUSED);
     1026        if (!async_data_read_receive(&chandle, &size)) {
     1027                async_answer_0(chandle, EREFUSED);
     1028                async_answer_0(icall_handle, EREFUSED);
    10291029                return;
    10301030        }
    … …  
    10331033        data = malloc(size);
    10341034        if (data == NULL) {
    1035                 async_answer_0(callid, ENOMEM);
    1036                 async_answer_0(iid, ENOMEM);
     1035                async_answer_0(chandle, ENOMEM);
     1036                async_answer_0(icall_handle, ENOMEM);
    10371037                return;
    10381038        }
    … …  
    10401040        rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
    10411041        if (rc != EOK) {
    1042                 async_answer_0(callid, rc);
    1043                 async_answer_0(iid, rc);
     1042                async_answer_0(chandle, rc);
     1043                async_answer_0(icall_handle, rc);
    10441044                free(data);
    10451045                return;
    10461046        }
    10471047
    1048         rc = async_data_read_finalize(callid, data, size);
    1049         if (rc != EOK) {
    1050                 async_answer_0(iid, rc);
     1048        rc = async_data_read_finalize(chandle, data, size);
     1049        if (rc != EOK) {
     1050                async_answer_0(icall_handle, rc);
    10511051                free(data);
    10521052                return;
    10531053        }
    10541054
    1055         async_answer_1(iid, EOK, rsize);
     1055        async_answer_1(icall_handle, EOK, rsize);
    10561056        free(data);
    10571057
    … …  
    10631063 * Handle client request to read received data via connection with blocking.
    10641064 *
    1065  * @param client   TCP client
    1066  * @param iid      Async request ID
    1067  * @param icall    Async request data
    1068  */
    1069 static void tcp_conn_recv_wait_srv(tcp_client_t *client, cap_call_handle_t iid,
    1070     ipc_call_t *icall)
    1071 {
    1072         cap_call_handle_t callid;
     1065 * @param client        TCP client
     1066 * @param icall_handle  Async request call handle
     1067 * @param icall         Async request data
     1068 */
     1069static void tcp_conn_recv_wait_srv(tcp_client_t *client,
     1070    cap_call_handle_t icall_handle, ipc_call_t *icall)
     1071{
     1072        cap_call_handle_t chandle;
    10731073        sysarg_t conn_id;
    10741074        size_t size, rsize;
    … …  
    10801080        conn_id = IPC_GET_ARG1(*icall);
    10811081
    1082         if (!async_data_read_receive(&callid, &size)) {
     1082        if (!async_data_read_receive(&chandle, &size)) {
    10831083                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - data_receive failed");
    1084                 async_answer_0(callid, EREFUSED);
    1085                 async_answer_0(iid, EREFUSED);
     1084                async_answer_0(chandle, EREFUSED);
     1085                async_answer_0(icall_handle, EREFUSED);
    10861086                return;
    10871087        }
    … …  
    10911091        if (data == NULL) {
    10921092                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - allocation failed");
    1093                 async_answer_0(callid, ENOMEM);
    1094                 async_answer_0(iid, ENOMEM);
     1093                async_answer_0(chandle, ENOMEM);
     1094                async_answer_0(icall_handle, ENOMEM);
    10951095                return;
    10961096        }
    … …  
    10991099        if (rc != EOK) {
    11001100                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - recv_impl failed rc=%s", str_error_name(rc));
    1101                 async_answer_0(callid, rc);
    1102                 async_answer_0(iid, rc);
     1101                async_answer_0(chandle, rc);
     1102                async_answer_0(icall_handle, rc);
    11031103                free(data);
    11041104                return;
    11051105        }
    11061106
    1107         rc = async_data_read_finalize(callid, data, size);
     1107        rc = async_data_read_finalize(chandle, data, size);
    11081108        if (rc != EOK) {
    11091109                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - finalize failed");
    1110                 async_answer_0(iid, rc);
     1110                async_answer_0(icall_handle, rc);
    11111111                free(data);
    11121112                return;
    … …  
    11141114
    11151115        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): rsize=%zu", size);
    1116         async_answer_1(iid, EOK, rsize);
     1116        async_answer_1(icall_handle, EOK, rsize);
    11171117        free(data);
    11181118
    … …  
    11681168/** Handle TCP client connection.
    11691169 *
    1170  * @param iid   Connect call ID
    1171  * @param icall Connect call data
    1172  * @param arg   Connection argument
    1173  */
    1174 static void tcp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     1170 * @param icall_handle  Connect call handle
     1171 * @param icall         Connect call data
     1172 * @param arg           Connection argument
     1173 */
     1174static void tcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
     1175    void *arg)
    11751176{
    11761177        tcp_client_t client;
    11771178
    11781179        /* Accept the connection */
    1179         async_answer_0(iid, EOK);
     1180        async_answer_0(icall_handle, EOK);
    11801181
    11811182        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn() - client=%p",
    … …  
    11871188                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: wait req");
    11881189                ipc_call_t call;
    1189                 cap_call_handle_t callid = async_get_call(&call);
     1190                cap_call_handle_t chandle = async_get_call(&call);
    11901191                sysarg_t method = IPC_GET_IMETHOD(call);
    11911192
    … …  
    11941195                if (!method) {
    11951196                        /* The other side has hung up */
    1196                         async_answer_0(callid, EOK);
     1197                        async_answer_0(chandle, EOK);
    11971198                        break;
    11981199                }
    … …  
    12001201                switch (method) {
    12011202                case TCP_CALLBACK_CREATE:
    1202                         tcp_callback_create_srv(&client, callid, &call);
     1203                        tcp_callback_create_srv(&client, chandle, &call);
    12031204                        break;
    12041205                case TCP_CONN_CREATE:
    1205                         tcp_conn_create_srv(&client, callid, &call);
     1206                        tcp_conn_create_srv(&client, chandle, &call);
    12061207                        break;
    12071208                case TCP_CONN_DESTROY:
    1208                         tcp_conn_destroy_srv(&client, callid, &call);
     1209                        tcp_conn_destroy_srv(&client, chandle, &call);
    12091210                        break;
    12101211                case TCP_LISTENER_CREATE:
    1211                         tcp_listener_create_srv(&client, callid, &call);
     1212                        tcp_listener_create_srv(&client, chandle, &call);
    12121213                        break;
    12131214                case TCP_LISTENER_DESTROY:
    1214                         tcp_listener_destroy_srv(&client, callid, &call);
     1215                        tcp_listener_destroy_srv(&client, chandle, &call);
    12151216                        break;
    12161217                case TCP_CONN_SEND_FIN:
    1217                         tcp_conn_send_fin_srv(&client, callid, &call);
     1218                        tcp_conn_send_fin_srv(&client, chandle, &call);
    12181219                        break;
    12191220                case TCP_CONN_PUSH:
    1220                         tcp_conn_push_srv(&client, callid, &call);
     1221                        tcp_conn_push_srv(&client, chandle, &call);
    12211222                        break;
    12221223                case TCP_CONN_RESET:
    1223                         tcp_conn_reset_srv(&client, callid, &call);
     1224                        tcp_conn_reset_srv(&client, chandle, &call);
    12241225                        break;
    12251226                case TCP_CONN_SEND:
    1226                         tcp_conn_send_srv(&client, callid, &call);
     1227                        tcp_conn_send_srv(&client, chandle, &call);
    12271228                        break;
    12281229                case TCP_CONN_RECV:
    1229                         tcp_conn_recv_srv(&client, callid, &call);
     1230                        tcp_conn_recv_srv(&client, chandle, &call);
    12301231                        break;
    12311232                case TCP_CONN_RECV_WAIT:
    1232                         tcp_conn_recv_wait_srv(&client, callid, &call);
     1233                        tcp_conn_recv_wait_srv(&client, chandle, &call);
    12331234                        break;
    12341235                default:
    1235                         async_answer_0(callid, ENOTSUP);
     1236                        async_answer_0(chandle, ENOTSUP);
    12361237                        break;
    12371238                }

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

    r3e242d2 ra46e56b  
    335335 * @param icall    Async request data
    336336 */
    337 static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t iid,
     337static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    338338    ipc_call_t *icall)
    339339{
    … …  
    342342        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    343343        if (sess == NULL) {
    344                 async_answer_0(iid, ENOMEM);
     344                async_answer_0(icall_handle, ENOMEM);
    345345                return;
    346346        }
    347347
    348348        client->sess = sess;
    349         async_answer_0(iid, EOK);
     349        async_answer_0(icall_handle, EOK);
    350350}
    351351
    … …  
    358358 * @param icall    Async request data
    359359 */
    360 static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t iid,
     360static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    361361    ipc_call_t *icall)
    362362{
    363         cap_call_handle_t callid;
     363        cap_call_handle_t chandle;
    364364        size_t size;
    365365        inet_ep2_t epp;
    … …  
    369369        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
    370370
    371         if (!async_data_write_receive(&callid, &size)) {
    372                 async_answer_0(callid, EREFUSED);
    373                 async_answer_0(iid, EREFUSED);
     371        if (!async_data_write_receive(&chandle, &size)) {
     372                async_answer_0(chandle, EREFUSED);
     373                async_answer_0(icall_handle, EREFUSED);
    374374                return;
    375375        }
    376376
    377377        if (size != sizeof(inet_ep2_t)) {
    378                 async_answer_0(callid, EINVAL);
    379                 async_answer_0(iid, EINVAL);
    380                 return;
    381         }
    382 
    383         rc = async_data_write_finalize(callid, &epp, size);
    384         if (rc != EOK) {
    385                 async_answer_0(callid, rc);
    386                 async_answer_0(iid, rc);
     378                async_answer_0(chandle, EINVAL);
     379                async_answer_0(icall_handle, EINVAL);
     380                return;
     381        }
     382
     383        rc = async_data_write_finalize(chandle, &epp, size);
     384        if (rc != EOK) {
     385                async_answer_0(chandle, rc);
     386                async_answer_0(icall_handle, rc);
    387387                return;
    388388        }
    … …  
    390390        rc = udp_assoc_create_impl(client, &epp, &assoc_id);
    391391        if (rc != EOK) {
    392                 async_answer_0(iid, rc);
    393                 return;
    394         }
    395 
    396         async_answer_1(iid, EOK, assoc_id);
     392                async_answer_0(icall_handle, rc);
     393                return;
     394        }
     395
     396        async_answer_1(icall_handle, EOK, assoc_id);
    397397}
    398398
    … …  
    405405 * @param icall    Async request data
    406406 */
    407 static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t iid,
     407static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    408408    ipc_call_t *icall)
    409409{
    … …  
    415415        assoc_id = IPC_GET_ARG1(*icall);
    416416        rc = udp_assoc_destroy_impl(client, assoc_id);
    417         async_answer_0(iid, rc);
     417        async_answer_0(icall_handle, rc);
    418418}
    419419
    … …  
    426426 * @param icall    Async request data
    427427 */
    428 static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t iid,
     428static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    429429    ipc_call_t *icall)
    430430{
    … …  
    436436        assoc_id = IPC_GET_ARG1(*icall);
    437437        rc = udp_assoc_set_nolocal_impl(client, assoc_id);
    438         async_answer_0(iid, rc);
     438        async_answer_0(icall_handle, rc);
    439439}
    440440
    … …  
    447447 * @param icall    Async request data
    448448 */
    449 static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t iid,
     449static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    450450    ipc_call_t *icall)
    451451{
    452         cap_call_handle_t callid;
     452        cap_call_handle_t chandle;
    453453        size_t size;
    454454        inet_ep_t dest;
    … …  
    461461        /* Receive dest */
    462462
    463         if (!async_data_write_receive(&callid, &size)) {
    464                 async_answer_0(callid, EREFUSED);
    465                 async_answer_0(iid, EREFUSED);
     463        if (!async_data_write_receive(&chandle, &size)) {
     464                async_answer_0(chandle, EREFUSED);
     465                async_answer_0(icall_handle, EREFUSED);
    466466                return;
    467467        }
    468468
    469469        if (size != sizeof(inet_ep_t)) {
    470                 async_answer_0(callid, EINVAL);
    471                 async_answer_0(iid, EINVAL);
    472                 return;
    473         }
    474 
    475         rc = async_data_write_finalize(callid, &dest, size);
    476         if (rc != EOK) {
    477                 async_answer_0(callid, rc);
    478                 async_answer_0(iid, rc);
     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);
    479479                return;
    480480        }
    … …  
    482482        /* Receive message data */
    483483
    484         if (!async_data_write_receive(&callid, &size)) {
    485                 async_answer_0(callid, EREFUSED);
    486                 async_answer_0(iid, EREFUSED);
     484        if (!async_data_write_receive(&chandle, &size)) {
     485                async_answer_0(chandle, EREFUSED);
     486                async_answer_0(icall_handle, EREFUSED);
    487487                return;
    488488        }
    489489
    490490        if (size > MAX_MSG_SIZE) {
    491                 async_answer_0(callid, EINVAL);
    492                 async_answer_0(iid, EINVAL);
     491                async_answer_0(chandle, EINVAL);
     492                async_answer_0(icall_handle, EINVAL);
    493493                return;
    494494        }
    … …  
    496496        data = malloc(size);
    497497        if (data == NULL) {
    498                 async_answer_0(callid, ENOMEM);
    499                 async_answer_0(iid, ENOMEM);
    500         }
    501 
    502         rc = async_data_write_finalize(callid, data, size);
    503         if (rc != EOK) {
    504                 async_answer_0(callid, rc);
    505                 async_answer_0(iid, rc);
     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);
    506506                free(data);
    507507                return;
    … …  
    512512        rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
    513513        if (rc != EOK) {
    514                 async_answer_0(iid, rc);
     514                async_answer_0(icall_handle, rc);
    515515                free(data);
    516516                return;
    517517        }
    518518
    519         async_answer_0(iid, EOK);
     519        async_answer_0(icall_handle, EOK);
    520520        free(data);
    521521}
    … …  
    545545 * @param icall    Async request data
    546546 */
    547 static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t iid,
     547static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    548548    ipc_call_t *icall)
    549549{
    550         cap_call_handle_t callid;
     550        cap_call_handle_t chandle;
    551551        size_t size;
    552552        udp_crcv_queue_entry_t *enext;
    … …  
    557557        enext = udp_rmsg_get_next(client);
    558558
    559         if (!async_data_read_receive(&callid, &size)) {
    560                 async_answer_0(callid, EREFUSED);
    561                 async_answer_0(iid, EREFUSED);
     559        if (!async_data_read_receive(&chandle, &size)) {
     560                async_answer_0(chandle, EREFUSED);
     561                async_answer_0(icall_handle, EREFUSED);
    562562                return;
    563563        }
    564564
    565565        if (enext == NULL) {
    566                 async_answer_0(callid, ENOENT);
    567                 async_answer_0(iid, ENOENT);
    568                 return;
    569         }
    570 
    571         rc = async_data_read_finalize(callid, &enext->epp.remote,
     566                async_answer_0(chandle, ENOENT);
     567                async_answer_0(icall_handle, ENOENT);
     568                return;
     569        }
     570
     571        rc = async_data_read_finalize(chandle, &enext->epp.remote,
    572572            max(size, (size_t)sizeof(inet_ep_t)));
    573573        if (rc != EOK) {
    574                 async_answer_0(iid, rc);
     574                async_answer_0(icall_handle, rc);
    575575                return;
    576576        }
    … …  
    581581        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
    582582            "size=%zu", assoc_id, size);
    583         async_answer_2(iid, EOK, assoc_id, size);
     583        async_answer_2(icall_handle, EOK, assoc_id, size);
    584584}
    585585
    … …  
    592592 * @param icall    Async request data
    593593 */
    594 static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t iid,
     594static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    595595    ipc_call_t *icall)
    596596{
    597         cap_call_handle_t callid;
     597        cap_call_handle_t chandle;
    598598        size_t msg_size;
    599599        udp_crcv_queue_entry_t *enext;
    … …  
    608608        enext = udp_rmsg_get_next(client);
    609609
    610         if (!async_data_read_receive(&callid, &size)) {
    611                 async_answer_0(callid, EREFUSED);
    612                 async_answer_0(iid, EREFUSED);
     610        if (!async_data_read_receive(&chandle, &size)) {
     611                async_answer_0(chandle, EREFUSED);
     612                async_answer_0(icall_handle, EREFUSED);
    613613                return;
    614614        }
    615615
    616616        if (enext == NULL) {
    617                 async_answer_0(callid, ENOENT);
    618                 async_answer_0(iid, ENOENT);
     617                async_answer_0(chandle, ENOENT);
     618                async_answer_0(icall_handle, ENOENT);
    619619                return;
    620620        }
    … …  
    624624
    625625        if (off > msg_size) {
    626                 async_answer_0(callid, EINVAL);
    627                 async_answer_0(iid, EINVAL);
    628                 return;
    629         }
    630 
    631         rc = async_data_read_finalize(callid, data, min(msg_size - off, size));
    632         if (rc != EOK) {
    633                 async_answer_0(iid, rc);
    634                 return;
    635         }
    636 
    637         async_answer_0(iid, EOK);
     626                async_answer_0(chandle, EINVAL);
     627                async_answer_0(icall_handle, EINVAL);
     628                return;
     629        }
     630
     631        rc = async_data_read_finalize(chandle, data, min(msg_size - off, size));
     632        if (rc != EOK) {
     633                async_answer_0(icall_handle, rc);
     634                return;
     635        }
     636
     637        async_answer_0(icall_handle, EOK);
    638638        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
    639639}
    … …  
    648648 * @param icall    Async request data
    649649 */
    650 static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t iid,
     650static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    651651    ipc_call_t *icall)
    652652{
    … …  
    658658        if (enext == NULL) {
    659659                log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
    660                 async_answer_0(iid, ENOENT);
     660                async_answer_0(icall_handle, ENOENT);
    661661                return;
    662662        }
    … …  
    665665        udp_msg_delete(enext->msg);
    666666        free(enext);
    667         async_answer_0(iid, EOK);
     667        async_answer_0(icall_handle, EOK);
    668668}
    669669
    … …  
    674674 * @param arg   Connection argument
    675675 */
    676 static void udp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     676static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    677677{
    678678        udp_client_t client;
    … …  
    680680
    681681        /* Accept the connection */
    682         async_answer_0(iid, EOK);
     682        async_answer_0(icall_handle, EOK);
    683683
    684684        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
    … …  
    691691                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
    692692                ipc_call_t call;
    693                 cap_call_handle_t callid = async_get_call(&call);
     693                cap_call_handle_t chandle = async_get_call(&call);
    694694                sysarg_t method = IPC_GET_IMETHOD(call);
    695695
    … …  
    698698                if (!method) {
    699699                        /* The other side has hung up */
    700                         async_answer_0(callid, EOK);
     700                        async_answer_0(chandle, EOK);
    701701                        break;
    702702                }
    … …  
    704704                switch (method) {
    705705                case UDP_CALLBACK_CREATE:
    706                         udp_callback_create_srv(&client, callid, &call);
     706                        udp_callback_create_srv(&client, chandle, &call);
    707707                        break;
    708708                case UDP_ASSOC_CREATE:
    709                         udp_assoc_create_srv(&client, callid, &call);
     709                        udp_assoc_create_srv(&client, chandle, &call);
    710710                        break;
    711711                case UDP_ASSOC_DESTROY:
    712                         udp_assoc_destroy_srv(&client, callid, &call);
     712                        udp_assoc_destroy_srv(&client, chandle, &call);
    713713                        break;
    714714                case UDP_ASSOC_SET_NOLOCAL:
    715                         udp_assoc_set_nolocal_srv(&client, callid, &call);
     715                        udp_assoc_set_nolocal_srv(&client, chandle, &call);
    716716                        break;
    717717                case UDP_ASSOC_SEND_MSG:
    718                         udp_assoc_send_msg_srv(&client, callid, &call);
     718                        udp_assoc_send_msg_srv(&client, chandle, &call);
    719719                        break;
    720720                case UDP_RMSG_INFO:
    721                         udp_rmsg_info_srv(&client, callid, &call);
     721                        udp_rmsg_info_srv(&client, chandle, &call);
    722722                        break;
    723723                case UDP_RMSG_READ:
    724                         udp_rmsg_read_srv(&client, callid, &call);
     724                        udp_rmsg_read_srv(&client, chandle, &call);
    725725                        break;
    726726                case UDP_RMSG_DISCARD:
    727                         udp_rmsg_discard_srv(&client, callid, &call);
     727                        udp_rmsg_discard_srv(&client, chandle, &call);
    728728                        break;
    729729                default:
    730                         async_answer_0(callid, ENOTSUP);
     730                        async_answer_0(chandle, ENOTSUP);
    731731                        break;
    732732                }
Note: See TracChangeset for help on using the changeset viewer.