Changeset a46e56b in mainline for uspace/srv/net/inetsrv/inetcfg.c


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

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