Changeset 984a9ba in mainline for uspace/srv/net/inetsrv


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

do not expose the call capability handler from the async framework

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

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

Location:
uspace/srv/net/inetsrv
Files:
5 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        }

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

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

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

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

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

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

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

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