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


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

do not expose the call capability handler from the async framework

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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

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