Changeset a46e56b in mainline for uspace/srv/net/inetsrv


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 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/inetsrv
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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        }
Note: See TracChangeset for help on using the changeset viewer.