Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/locsrv/locsrv.c

    ra35b458 ra46e56b  
    339339{
    340340        ipc_call_t icall;
    341         ipc_callid_t iid = async_get_call(&icall);
     341        cap_call_handle_t icall_handle = async_get_call(&icall);
    342342
    343343        if (IPC_GET_IMETHOD(icall) != LOC_SERVER_REGISTER) {
    344                 async_answer_0(iid, EREFUSED);
     344                async_answer_0(icall_handle, EREFUSED);
    345345                return NULL;
    346346        }
    … …  
    349349            (loc_server_t *) malloc(sizeof(loc_server_t));
    350350        if (server == NULL) {
    351                 async_answer_0(iid, ENOMEM);
     351                async_answer_0(icall_handle, ENOMEM);
    352352                return NULL;
    353353        }
    … …  
    360360        if (rc != EOK) {
    361361                free(server);
    362                 async_answer_0(iid, rc);
     362                async_answer_0(icall_handle, rc);
    363363                return NULL;
    364364        }
    … …  
    371371                free(server->name);
    372372                free(server);
    373                 async_answer_0(iid, ENOTSUP);
     373                async_answer_0(icall_handle, ENOTSUP);
    374374                return NULL;
    375375        }
    … …  
    400400        fibril_mutex_unlock(&servers_list_mutex);
    401401
    402         async_answer_0(iid, EOK);
     402        async_answer_0(icall_handle, EOK);
    403403
    404404        return server;
    … …  
    453453 *
    454454 */
    455 static void loc_service_register(ipc_callid_t iid, ipc_call_t *icall,
     455static void loc_service_register(cap_call_handle_t icall_handle, ipc_call_t *icall,
    456456    loc_server_t *server)
    457457{
    458458        if (server == NULL) {
    459                 async_answer_0(iid, EREFUSED);
     459                async_answer_0(icall_handle, EREFUSED);
    460460                return;
    461461        }
    … …  
    465465            (loc_service_t *) malloc(sizeof(loc_service_t));
    466466        if (service == NULL) {
    467                 async_answer_0(iid, ENOMEM);
     467                async_answer_0(icall_handle, ENOMEM);
    468468                return;
    469469        }
    … …  
    475475        if (rc != EOK) {
    476476                free(service);
    477                 async_answer_0(iid, rc);
     477                async_answer_0(icall_handle, rc);
    478478                return;
    479479        }
    … …  
    483483                free(fqsn);
    484484                free(service);
    485                 async_answer_0(iid, EINVAL);
     485                async_answer_0(icall_handle, EINVAL);
    486486                return;
    487487        }
    … …  
    497497                free(service->name);
    498498                free(service);
    499                 async_answer_0(iid, ENOMEM);
     499                async_answer_0(icall_handle, ENOMEM);
    500500                return;
    501501        }
    … …  
    513513                free(service->name);
    514514                free(service);
    515                 async_answer_0(iid, EEXIST);
     515                async_answer_0(icall_handle, EEXIST);
    516516                return;
    517517        }
    … …  
    535535        fibril_mutex_unlock(&services_list_mutex);
    536536
    537         async_answer_1(iid, EOK, service->id);
     537        async_answer_1(icall_handle, EOK, service->id);
    538538}
    539539
    … …  
    541541 *
    542542 */
    543 static void loc_service_unregister(ipc_callid_t iid, ipc_call_t *icall,
     543static void loc_service_unregister(cap_call_handle_t icall_handle, ipc_call_t *icall,
    544544    loc_server_t *server)
    545545{
    … …  
    550550        if (svc == NULL) {
    551551                fibril_mutex_unlock(&services_list_mutex);
    552                 async_answer_0(iid, ENOENT);
     552                async_answer_0(icall_handle, ENOENT);
    553553                return;
    554554        }
    … …  
    565565         */
    566566        loc_category_change_event();
    567         async_answer_0(iid, EOK);
    568 }
    569 
    570 static void loc_category_get_name(ipc_callid_t iid, ipc_call_t *icall)
    571 {
    572         ipc_callid_t callid;
     567        async_answer_0(icall_handle, EOK);
     568}
     569
     570static void loc_category_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
     571{
     572        cap_call_handle_t chandle;
    573573        size_t size;
    574574        size_t act_size;
    575575        category_t *cat;
    576576
    577         if (!async_data_read_receive(&callid, &size)) {
    578                 async_answer_0(callid, EREFUSED);
    579                 async_answer_0(iid, EREFUSED);
     577        if (!async_data_read_receive(&chandle, &size)) {
     578                async_answer_0(chandle, EREFUSED);
     579                async_answer_0(icall_handle, EREFUSED);
    580580                return;
    581581        }
    … …  
    586586        if (cat == NULL) {
    587587                fibril_mutex_unlock(&cdir.mutex);
    588                 async_answer_0(callid, ENOENT);
    589                 async_answer_0(iid, ENOENT);
     588                async_answer_0(chandle, ENOENT);
     589                async_answer_0(icall_handle, ENOENT);
    590590                return;
    591591        }
    … …  
    594594        if (act_size > size) {
    595595                fibril_mutex_unlock(&cdir.mutex);
    596                 async_answer_0(callid, EOVERFLOW);
    597                 async_answer_0(iid, EOVERFLOW);
    598                 return;
    599         }
    600 
    601         errno_t retval = async_data_read_finalize(callid, cat->name,
     596                async_answer_0(chandle, EOVERFLOW);
     597                async_answer_0(icall_handle, EOVERFLOW);
     598                return;
     599        }
     600
     601        errno_t retval = async_data_read_finalize(chandle, cat->name,
    602602            min(size, act_size));
    603603
    604604        fibril_mutex_unlock(&cdir.mutex);
    605605
    606         async_answer_0(iid, retval);
    607 }
    608 
    609 static void loc_service_get_name(ipc_callid_t iid, ipc_call_t *icall)
    610 {
    611         ipc_callid_t callid;
     606        async_answer_0(icall_handle, retval);
     607}
     608
     609static void loc_service_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
     610{
     611        cap_call_handle_t chandle;
    612612        size_t size;
    613613        size_t act_size;
    … …  
    615615        char *fqn;
    616616
    617         if (!async_data_read_receive(&callid, &size)) {
    618                 async_answer_0(callid, EREFUSED);
    619                 async_answer_0(iid, EREFUSED);
     617        if (!async_data_read_receive(&chandle, &size)) {
     618                async_answer_0(chandle, EREFUSED);
     619                async_answer_0(icall_handle, EREFUSED);
    620620                return;
    621621        }
    … …  
    626626        if (svc == NULL) {
    627627                fibril_mutex_unlock(&services_list_mutex);
    628                 async_answer_0(callid, ENOENT);
    629                 async_answer_0(iid, ENOENT);
     628                async_answer_0(chandle, ENOENT);
     629                async_answer_0(icall_handle, ENOENT);
    630630                return;
    631631        }
    … …  
    633633        if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
    634634                fibril_mutex_unlock(&services_list_mutex);
    635                 async_answer_0(callid, ENOMEM);
    636                 async_answer_0(iid, ENOMEM);
     635                async_answer_0(chandle, ENOMEM);
     636                async_answer_0(icall_handle, ENOMEM);
    637637                return;
    638638        }
    … …  
    642642                free(fqn);
    643643                fibril_mutex_unlock(&services_list_mutex);
    644                 async_answer_0(callid, EOVERFLOW);
    645                 async_answer_0(iid, EOVERFLOW);
    646                 return;
    647         }
    648 
    649         errno_t retval = async_data_read_finalize(callid, fqn,
     644                async_answer_0(chandle, EOVERFLOW);
     645                async_answer_0(icall_handle, EOVERFLOW);
     646                return;
     647        }
     648
     649        errno_t retval = async_data_read_finalize(chandle, fqn,
    650650            min(size, act_size));
    651651        free(fqn);
    … …  
    653653        fibril_mutex_unlock(&services_list_mutex);
    654654
    655         async_answer_0(iid, retval);
    656 }
    657 
    658 static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
    659 {
    660         ipc_callid_t callid;
     655        async_answer_0(icall_handle, retval);
     656}
     657
     658static void loc_service_get_server_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
     659{
     660        cap_call_handle_t chandle;
    661661        size_t size;
    662662        size_t act_size;
    663663        loc_service_t *svc;
    664664
    665         if (!async_data_read_receive(&callid, &size)) {
    666                 async_answer_0(callid, EREFUSED);
    667                 async_answer_0(iid, EREFUSED);
     665        if (!async_data_read_receive(&chandle, &size)) {
     666                async_answer_0(chandle, EREFUSED);
     667                async_answer_0(icall_handle, EREFUSED);
    668668                return;
    669669        }
    … …  
    674674        if (svc == NULL) {
    675675                fibril_mutex_unlock(&services_list_mutex);
    676                 async_answer_0(callid, ENOENT);
    677                 async_answer_0(iid, ENOENT);
     676                async_answer_0(chandle, ENOENT);
     677                async_answer_0(icall_handle, ENOENT);
    678678                return;
    679679        }
    … …  
    681681        if (svc->server == NULL) {
    682682                fibril_mutex_unlock(&services_list_mutex);
    683                 async_answer_0(callid, EINVAL);
    684                 async_answer_0(iid, EINVAL);
     683                async_answer_0(chandle, EINVAL);
     684                async_answer_0(icall_handle, EINVAL);
    685685                return;
    686686        }
    … …  
    689689        if (act_size > size) {
    690690                fibril_mutex_unlock(&services_list_mutex);
    691                 async_answer_0(callid, EOVERFLOW);
    692                 async_answer_0(iid, EOVERFLOW);
    693                 return;
    694         }
    695 
    696         errno_t retval = async_data_read_finalize(callid, svc->server->name,
     691                async_answer_0(chandle, EOVERFLOW);
     692                async_answer_0(icall_handle, EOVERFLOW);
     693                return;
     694        }
     695
     696        errno_t retval = async_data_read_finalize(chandle, svc->server->name,
    697697            min(size, act_size));
    698698
    699699        fibril_mutex_unlock(&services_list_mutex);
    700700
    701         async_answer_0(iid, retval);
     701        async_answer_0(icall_handle, retval);
    702702}
    703703
    … …  
    708708 *
    709709 */
    710 static void loc_forward(ipc_callid_t callid, ipc_call_t *call, void *arg)
     710static void loc_forward(cap_call_handle_t chandle, ipc_call_t *call, void *arg)
    711711{
    712712        fibril_mutex_lock(&services_list_mutex);
    … …  
    721721        if ((svc == NULL) || (svc->server == NULL) || (!svc->server->sess)) {
    722722                fibril_mutex_unlock(&services_list_mutex);
    723                 async_answer_0(callid, ENOENT);
     723                async_answer_0(chandle, ENOENT);
    724724                return;
    725725        }
    726726
    727727        async_exch_t *exch = async_exchange_begin(svc->server->sess);
    728         async_forward_fast(callid, exch, iface, svc->id, 0, IPC_FF_NONE);
     728        async_forward_fast(chandle, exch, iface, svc->id, 0, IPC_FF_NONE);
    729729        async_exchange_end(exch);
    730730
    … …  
    738738 *
    739739 */
    740 static void loc_service_get_id(ipc_callid_t iid, ipc_call_t *icall)
     740static void loc_service_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
    741741{
    742742        char *fqsn;
    … …  
    746746            LOC_NAME_MAXLEN, 0, NULL);
    747747        if (rc != EOK) {
    748                 async_answer_0(iid, rc);
     748                async_answer_0(icall_handle, rc);
    749749                return;
    750750        }
    … …  
    754754        if (!loc_fqsn_split(fqsn, &ns_name, &name)) {
    755755                free(fqsn);
    756                 async_answer_0(iid, EINVAL);
     756                async_answer_0(icall_handle, EINVAL);
    757757                return;
    758758        }
    … …  
    781781                }
    782782
    783                 async_answer_0(iid, ENOENT);
     783                async_answer_0(icall_handle, ENOENT);
    784784                free(ns_name);
    785785                free(name);
    … …  
    788788        }
    789789
    790         async_answer_1(iid, EOK, svc->id);
     790        async_answer_1(icall_handle, EOK, svc->id);
    791791
    792792        fibril_mutex_unlock(&services_list_mutex);
    … …  
    801801 *
    802802 */
    803 static void loc_namespace_get_id(ipc_callid_t iid, ipc_call_t *icall)
     803static void loc_namespace_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
    804804{
    805805        char *name;
    … …  
    809809            LOC_NAME_MAXLEN, 0, NULL);
    810810        if (rc != EOK) {
    811                 async_answer_0(iid, rc);
     811                async_answer_0(icall_handle, rc);
    812812                return;
    813813        }
    … …  
    834834                }
    835835
    836                 async_answer_0(iid, ENOENT);
     836                async_answer_0(icall_handle, ENOENT);
    837837                free(name);
    838838                fibril_mutex_unlock(&services_list_mutex);
    … …  
    840840        }
    841841
    842         async_answer_1(iid, EOK, namespace->id);
     842        async_answer_1(icall_handle, EOK, namespace->id);
    843843
    844844        fibril_mutex_unlock(&services_list_mutex);
    … …  
    855855 *
    856856 */
    857 static void loc_callback_create(ipc_callid_t iid, ipc_call_t *icall)
     857static void loc_callback_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
    858858{
    859859        cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
    860860        if (cb_sess == NULL) {
    861                 async_answer_0(iid, ENOMEM);
     861                async_answer_0(icall_handle, ENOMEM);
    862862                return;
    863863        }
    … …  
    866866        if (sess == NULL) {
    867867                free(cb_sess);
    868                 async_answer_0(iid, ENOMEM);
     868                async_answer_0(icall_handle, ENOMEM);
    869869                return;
    870870        }
    … …  
    877877        fibril_mutex_unlock(&callback_sess_mutex);
    878878
    879         async_answer_0(iid, EOK);
     879        async_answer_0(icall_handle, EOK);
    880880}
    881881
    … …  
    899899 *
    900900 */
    901 static void loc_category_get_id(ipc_callid_t iid, ipc_call_t *icall)
     901static void loc_category_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
    902902{
    903903        char *name;
    … …  
    908908            LOC_NAME_MAXLEN, 0, NULL);
    909909        if (rc != EOK) {
    910                 async_answer_0(iid, rc);
     910                async_answer_0(icall_handle, rc);
    911911                return;
    912912        }
    … …  
    917917        if (cat == NULL) {
    918918                /* Category not found */
    919                 async_answer_0(iid, ENOENT);
     919                async_answer_0(icall_handle, ENOENT);
    920920                goto cleanup;
    921921        }
    922922
    923         async_answer_1(iid, EOK, cat->id);
     923        async_answer_1(icall_handle, EOK, cat->id);
    924924cleanup:
    925925        fibril_mutex_unlock(&cdir.mutex);
    … …  
    927927}
    928928
    929 static void loc_id_probe(ipc_callid_t iid, ipc_call_t *icall)
     929static void loc_id_probe(cap_call_handle_t icall_handle, ipc_call_t *icall)
    930930{
    931931        fibril_mutex_lock(&services_list_mutex);
    … …  
    937937                    loc_service_find_id(IPC_GET_ARG1(*icall));
    938938                if (svc == NULL)
    939                         async_answer_1(iid, EOK, LOC_OBJECT_NONE);
     939                        async_answer_1(icall_handle, EOK, LOC_OBJECT_NONE);
    940940                else
    941                         async_answer_1(iid, EOK, LOC_OBJECT_SERVICE);
     941                        async_answer_1(icall_handle, EOK, LOC_OBJECT_SERVICE);
    942942        } else
    943                 async_answer_1(iid, EOK, LOC_OBJECT_NAMESPACE);
     943                async_answer_1(icall_handle, EOK, LOC_OBJECT_NAMESPACE);
    944944
    945945        fibril_mutex_unlock(&services_list_mutex);
    946946}
    947947
    948 static void loc_get_namespace_count(ipc_callid_t iid, ipc_call_t *icall)
     948static void loc_get_namespace_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
    949949{
    950950        fibril_mutex_lock(&services_list_mutex);
    951         async_answer_1(iid, EOK, list_count(&namespaces_list));
     951        async_answer_1(icall_handle, EOK, list_count(&namespaces_list));
    952952        fibril_mutex_unlock(&services_list_mutex);
    953953}
    954954
    955 static void loc_get_service_count(ipc_callid_t iid, ipc_call_t *icall)
     955static void loc_get_service_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
    956956{
    957957        fibril_mutex_lock(&services_list_mutex);
    … …  
    960960            loc_namespace_find_id(IPC_GET_ARG1(*icall));
    961961        if (namespace == NULL)
    962                 async_answer_0(iid, EEXIST);
     962                async_answer_0(icall_handle, EEXIST);
    963963        else
    964                 async_answer_1(iid, EOK, namespace->refcnt);
     964                async_answer_1(icall_handle, EOK, namespace->refcnt);
    965965
    966966        fibril_mutex_unlock(&services_list_mutex);
    967967}
    968968
    969 static void loc_get_categories(ipc_callid_t iid, ipc_call_t *icall)
    970 {
    971         ipc_callid_t callid;
     969static void loc_get_categories(cap_call_handle_t icall_handle, ipc_call_t *icall)
     970{
     971        cap_call_handle_t chandle;
    972972        size_t size;
    973973        size_t act_size;
    974974        errno_t rc;
    975975
    976         if (!async_data_read_receive(&callid, &size)) {
    977                 async_answer_0(callid, EREFUSED);
    978                 async_answer_0(iid, EREFUSED);
     976        if (!async_data_read_receive(&chandle, &size)) {
     977                async_answer_0(chandle, EREFUSED);
     978                async_answer_0(icall_handle, EREFUSED);
    979979                return;
    980980        }
    … …  
    983983        if (id_buf == NULL) {
    984984                fibril_mutex_unlock(&cdir.mutex);
    985                 async_answer_0(callid, ENOMEM);
    986                 async_answer_0(iid, ENOMEM);
     985                async_answer_0(chandle, ENOMEM);
     986                async_answer_0(icall_handle, ENOMEM);
    987987                return;
    988988        }
    … …  
    993993        if (rc != EOK) {
    994994                fibril_mutex_unlock(&cdir.mutex);
    995                 async_answer_0(callid, rc);
    996                 async_answer_0(iid, rc);
     995                async_answer_0(chandle, rc);
     996                async_answer_0(icall_handle, rc);
    997997                return;
    998998        }
    … …  
    10001000        fibril_mutex_unlock(&cdir.mutex);
    10011001
    1002         errno_t retval = async_data_read_finalize(callid, id_buf, size);
     1002        errno_t retval = async_data_read_finalize(chandle, id_buf, size);
    10031003        free(id_buf);
    10041004
    1005         async_answer_1(iid, retval, act_size);
    1006 }
    1007 
    1008 static void loc_get_namespaces(ipc_callid_t iid, ipc_call_t *icall)
    1009 {
    1010         ipc_callid_t callid;
     1005        async_answer_1(icall_handle, retval, act_size);
     1006}
     1007
     1008static void loc_get_namespaces(cap_call_handle_t icall_handle, ipc_call_t *icall)
     1009{
     1010        cap_call_handle_t chandle;
    10111011        size_t size;
    1012         if (!async_data_read_receive(&callid, &size)) {
    1013                 async_answer_0(callid, EREFUSED);
    1014                 async_answer_0(iid, EREFUSED);
     1012        if (!async_data_read_receive(&chandle, &size)) {
     1013                async_answer_0(chandle, EREFUSED);
     1014                async_answer_0(icall_handle, EREFUSED);
    10151015                return;
    10161016        }
    10171017
    10181018        if ((size % sizeof(loc_sdesc_t)) != 0) {
    1019                 async_answer_0(callid, EINVAL);
    1020                 async_answer_0(iid, EINVAL);
     1019                async_answer_0(chandle, EINVAL);
     1020                async_answer_0(icall_handle, EINVAL);
    10211021                return;
    10221022        }
    … …  
    10271027        if (count != list_count(&namespaces_list)) {
    10281028                fibril_mutex_unlock(&services_list_mutex);
    1029                 async_answer_0(callid, EOVERFLOW);
    1030                 async_answer_0(iid, EOVERFLOW);
     1029                async_answer_0(chandle, EOVERFLOW);
     1030                async_answer_0(icall_handle, EOVERFLOW);
    10311031                return;
    10321032        }
    … …  
    10351035        if (desc == NULL) {
    10361036                fibril_mutex_unlock(&services_list_mutex);
    1037                 async_answer_0(callid, ENOMEM);
    1038                 async_answer_0(iid, ENOMEM);
     1037                async_answer_0(chandle, ENOMEM);
     1038                async_answer_0(icall_handle, ENOMEM);
    10391039                return;
    10401040        }
    … …  
    10471047        }
    10481048
    1049         errno_t retval = async_data_read_finalize(callid, desc, size);
     1049        errno_t retval = async_data_read_finalize(chandle, desc, size);
    10501050
    10511051        free(desc);
    10521052        fibril_mutex_unlock(&services_list_mutex);
    10531053
    1054         async_answer_0(iid, retval);
    1055 }
    1056 
    1057 static void loc_get_services(ipc_callid_t iid, ipc_call_t *icall)
     1054        async_answer_0(icall_handle, retval);
     1055}
     1056
     1057static void loc_get_services(cap_call_handle_t icall_handle, ipc_call_t *icall)
    10581058{
    10591059        /* FIXME: Use faster algorithm which can make better use
    10601060           of namespaces */
    10611061
    1062         ipc_callid_t callid;
     1062        cap_call_handle_t chandle;
    10631063        size_t size;
    1064         if (!async_data_read_receive(&callid, &size)) {
    1065                 async_answer_0(callid, EREFUSED);
    1066                 async_answer_0(iid, EREFUSED);
     1064        if (!async_data_read_receive(&chandle, &size)) {
     1065                async_answer_0(chandle, EREFUSED);
     1066                async_answer_0(icall_handle, EREFUSED);
    10671067                return;
    10681068        }
    10691069
    10701070        if ((size % sizeof(loc_sdesc_t)) != 0) {
    1071                 async_answer_0(callid, EINVAL);
    1072                 async_answer_0(iid, EINVAL);
     1071                async_answer_0(chandle, EINVAL);
     1072                async_answer_0(icall_handle, EINVAL);
    10731073                return;
    10741074        }
    … …  
    10801080        if (namespace == NULL) {
    10811081                fibril_mutex_unlock(&services_list_mutex);
    1082                 async_answer_0(callid, ENOENT);
    1083                 async_answer_0(iid, ENOENT);
     1082                async_answer_0(chandle, ENOENT);
     1083                async_answer_0(icall_handle, ENOENT);
    10841084                return;
    10851085        }
    … …  
    10881088        if (count != namespace->refcnt) {
    10891089                fibril_mutex_unlock(&services_list_mutex);
    1090                 async_answer_0(callid, EOVERFLOW);
    1091                 async_answer_0(iid, EOVERFLOW);
     1090                async_answer_0(chandle, EOVERFLOW);
     1091                async_answer_0(icall_handle, EOVERFLOW);
    10921092                return;
    10931093        }
    … …  
    10961096        if (desc == NULL) {
    10971097                fibril_mutex_unlock(&services_list_mutex);
    1098                 async_answer_0(callid, ENOMEM);
    1099                 async_answer_0(iid, EREFUSED);
     1098                async_answer_0(chandle, ENOMEM);
     1099                async_answer_0(icall_handle, EREFUSED);
    11001100                return;
    11011101        }
    … …  
    11101110        }
    11111111
    1112         errno_t retval = async_data_read_finalize(callid, desc, size);
     1112        errno_t retval = async_data_read_finalize(chandle, desc, size);
    11131113
    11141114        free(desc);
    11151115        fibril_mutex_unlock(&services_list_mutex);
    11161116
    1117         async_answer_0(iid, retval);
    1118 }
    1119 
    1120 static void loc_category_get_svcs(ipc_callid_t iid, ipc_call_t *icall)
    1121 {
    1122         ipc_callid_t callid;
     1117        async_answer_0(icall_handle, retval);
     1118}
     1119
     1120static void loc_category_get_svcs(cap_call_handle_t icall_handle, ipc_call_t *icall)
     1121{
     1122        cap_call_handle_t chandle;
    11231123        size_t size;
    11241124        size_t act_size;
    11251125        errno_t rc;
    11261126
    1127         if (!async_data_read_receive(&callid, &size)) {
    1128                 async_answer_0(callid, EREFUSED);
    1129                 async_answer_0(iid, EREFUSED);
     1127        if (!async_data_read_receive(&chandle, &size)) {
     1128                async_answer_0(chandle, EREFUSED);
     1129                async_answer_0(icall_handle, EREFUSED);
    11301130                return;
    11311131        }
    … …  
    11361136        if (cat == NULL) {
    11371137                fibril_mutex_unlock(&cdir.mutex);
    1138                 async_answer_0(callid, ENOENT);
    1139                 async_answer_0(iid, ENOENT);
     1138                async_answer_0(chandle, ENOENT);
     1139                async_answer_0(icall_handle, ENOENT);
    11401140                return;
    11411141        }
    … …  
    11441144        if (id_buf == NULL) {
    11451145                fibril_mutex_unlock(&cdir.mutex);
    1146                 async_answer_0(callid, ENOMEM);
    1147                 async_answer_0(iid, ENOMEM);
     1146                async_answer_0(chandle, ENOMEM);
     1147                async_answer_0(icall_handle, ENOMEM);
    11481148                return;
    11491149        }
    … …  
    11551155                fibril_mutex_unlock(&cat->mutex);
    11561156                fibril_mutex_unlock(&cdir.mutex);
    1157                 async_answer_0(callid, rc);
    1158                 async_answer_0(iid, rc);
     1157                async_answer_0(chandle, rc);
     1158                async_answer_0(icall_handle, rc);
    11591159                return;
    11601160        }
    … …  
    11631163        fibril_mutex_unlock(&cdir.mutex);
    11641164
    1165         errno_t retval = async_data_read_finalize(callid, id_buf, size);
     1165        errno_t retval = async_data_read_finalize(chandle, id_buf, size);
    11661166        free(id_buf);
    11671167
    1168         async_answer_1(iid, retval, act_size);
    1169 }
    1170 
    1171 
    1172 static void loc_null_create(ipc_callid_t iid, ipc_call_t *icall)
     1168        async_answer_1(icall_handle, retval, act_size);
     1169}
     1170
     1171
     1172static void loc_null_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
    11731173{
    11741174        fibril_mutex_lock(&null_services_mutex);
    … …  
    11861186        if (!fnd) {
    11871187                fibril_mutex_unlock(&null_services_mutex);
    1188                 async_answer_0(iid, ENOMEM);
     1188                async_answer_0(icall_handle, ENOMEM);
    11891189                return;
    11901190        }
    … …  
    11961196        if (dev_name == NULL) {
    11971197                fibril_mutex_unlock(&null_services_mutex);
    1198                 async_answer_0(iid, ENOMEM);
     1198                async_answer_0(icall_handle, ENOMEM);
    11991199                return;
    12001200        }
    … …  
    12041204        if (service == NULL) {
    12051205                fibril_mutex_unlock(&null_services_mutex);
    1206                 async_answer_0(iid, ENOMEM);
     1206                async_answer_0(icall_handle, ENOMEM);
    12071207                return;
    12081208        }
    … …  
    12141214                fibril_mutex_lock(&services_list_mutex);
    12151215                fibril_mutex_unlock(&null_services_mutex);
    1216                 async_answer_0(iid, ENOMEM);
     1216                async_answer_0(icall_handle, ENOMEM);
    12171217                return;
    12181218        }
    … …  
    12411241        fibril_mutex_unlock(&null_services_mutex);
    12421242
    1243         async_answer_1(iid, EOK, (sysarg_t) i);
    1244 }
    1245 
    1246 static void loc_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
     1243        async_answer_1(icall_handle, EOK, (sysarg_t) i);
     1244}
     1245
     1246static void loc_null_destroy(cap_call_handle_t icall_handle, ipc_call_t *icall)
    12471247{
    12481248        sysarg_t i = IPC_GET_ARG1(*icall);
    12491249        if (i >= NULL_SERVICES) {
    1250                 async_answer_0(iid, ELIMIT);
     1250                async_answer_0(icall_handle, ELIMIT);
    12511251                return;
    12521252        }
    … …  
    12561256        if (null_services[i] == NULL) {
    12571257                fibril_mutex_unlock(&null_services_mutex);
    1258                 async_answer_0(iid, ENOENT);
     1258                async_answer_0(icall_handle, ENOENT);
    12591259                return;
    12601260        }
    … …  
    12691269
    12701270        fibril_mutex_unlock(&null_services_mutex);
    1271         async_answer_0(iid, EOK);
    1272 }
    1273 
    1274 static void loc_service_add_to_cat(ipc_callid_t iid, ipc_call_t *icall)
     1271        async_answer_0(icall_handle, EOK);
     1272}
     1273
     1274static void loc_service_add_to_cat(cap_call_handle_t icall_handle, ipc_call_t *icall)
    12751275{
    12761276        category_t *cat;
    … …  
    12921292                fibril_mutex_unlock(&cdir.mutex);
    12931293                fibril_mutex_unlock(&services_list_mutex);
    1294                 async_answer_0(iid, ENOENT);
     1294                async_answer_0(icall_handle, ENOENT);
    12951295                return;
    12961296        }
    … …  
    13091309         */
    13101310        loc_category_change_event();
    1311         async_answer_0(iid, retval);
     1311        async_answer_0(icall_handle, retval);
    13121312}
    13131313
    … …  
    13931393 *
    13941394 */
    1395 static void loc_connection_supplier(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     1395static void loc_connection_supplier(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    13961396{
    13971397        /* Accept connection */
    1398         async_answer_0(iid, EOK);
     1398        async_answer_0(icall_handle, EOK);
    13991399
    14001400        loc_server_t *server = loc_server_register();
    … …  
    14041404        while (true) {
    14051405                ipc_call_t call;
    1406                 ipc_callid_t callid = async_get_call(&call);
     1406                cap_call_handle_t chandle = async_get_call(&call);
    14071407
    14081408                if (!IPC_GET_IMETHOD(call))
    … …  
    14121412                case LOC_SERVER_UNREGISTER:
    14131413                        if (server == NULL)
    1414                                 async_answer_0(callid, ENOENT);
     1414                                async_answer_0(chandle, ENOENT);
    14151415                        else
    1416                                 async_answer_0(callid, EOK);
     1416                                async_answer_0(chandle, EOK);
    14171417                        break;
    14181418                case LOC_SERVICE_ADD_TO_CAT:
    14191419                        /* Add service to category */
    1420                         loc_service_add_to_cat(callid, &call);
     1420                        loc_service_add_to_cat(chandle, &call);
    14211421                        break;
    14221422                case LOC_SERVICE_REGISTER:
    14231423                        /* Register one service */
    1424                         loc_service_register(callid, &call, server);
     1424                        loc_service_register(chandle, &call, server);
    14251425                        break;
    14261426                case LOC_SERVICE_UNREGISTER:
    14271427                        /* Remove one service */
    1428                         loc_service_unregister(callid, &call, server);
     1428                        loc_service_unregister(chandle, &call, server);
    14291429                        break;
    14301430                case LOC_SERVICE_GET_ID:
    1431                         loc_service_get_id(callid, &call);
     1431                        loc_service_get_id(chandle, &call);
    14321432                        break;
    14331433                case LOC_NAMESPACE_GET_ID:
    1434                         loc_namespace_get_id(callid, &call);
     1434                        loc_namespace_get_id(chandle, &call);
    14351435                        break;
    14361436                default:
    1437                         async_answer_0(callid, ENOENT);
     1437                        async_answer_0(chandle, ENOENT);
    14381438                }
    14391439        }
    … …  
    14511451 *
    14521452 */
    1453 static void loc_connection_consumer(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     1453static void loc_connection_consumer(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    14541454{
    14551455        /* Accept connection */
    1456         async_answer_0(iid, EOK);
     1456        async_answer_0(icall_handle, EOK);
    14571457
    14581458        while (true) {
    14591459                ipc_call_t call;
    1460                 ipc_callid_t callid = async_get_call(&call);
     1460                cap_call_handle_t chandle = async_get_call(&call);
    14611461
    14621462                if (!IPC_GET_IMETHOD(call))
    … …  
    14651465                switch (IPC_GET_IMETHOD(call)) {
    14661466                case LOC_SERVICE_GET_ID:
    1467                         loc_service_get_id(callid, &call);
     1467                        loc_service_get_id(chandle, &call);
    14681468                        break;
    14691469                case LOC_SERVICE_GET_NAME:
    1470                         loc_service_get_name(callid, &call);
     1470                        loc_service_get_name(chandle, &call);
    14711471                        break;
    14721472                case LOC_SERVICE_GET_SERVER_NAME:
    1473                         loc_service_get_server_name(callid, &call);
     1473                        loc_service_get_server_name(chandle, &call);
    14741474                        break;
    14751475                case LOC_NAMESPACE_GET_ID:
    1476                         loc_namespace_get_id(callid, &call);
     1476                        loc_namespace_get_id(chandle, &call);
    14771477                        break;
    14781478                case LOC_CALLBACK_CREATE:
    1479                         loc_callback_create(callid, &call);
     1479                        loc_callback_create(chandle, &call);
    14801480                        break;
    14811481                case LOC_CATEGORY_GET_ID:
    1482                         loc_category_get_id(callid, &call);
     1482                        loc_category_get_id(chandle, &call);
    14831483                        break;
    14841484                case LOC_CATEGORY_GET_NAME:
    1485                         loc_category_get_name(callid, &call);
     1485                        loc_category_get_name(chandle, &call);
    14861486                        break;
    14871487                case LOC_CATEGORY_GET_SVCS:
    1488                         loc_category_get_svcs(callid, &call);
     1488                        loc_category_get_svcs(chandle, &call);
    14891489                        break;
    14901490                case LOC_ID_PROBE:
    1491                         loc_id_probe(callid, &call);
     1491                        loc_id_probe(chandle, &call);
    14921492                        break;
    14931493                case LOC_NULL_CREATE:
    1494                         loc_null_create(callid, &call);
     1494                        loc_null_create(chandle, &call);
    14951495                        break;
    14961496                case LOC_NULL_DESTROY:
    1497                         loc_null_destroy(callid, &call);
     1497                        loc_null_destroy(chandle, &call);
    14981498                        break;
    14991499                case LOC_GET_NAMESPACE_COUNT:
    1500                         loc_get_namespace_count(callid, &call);
     1500                        loc_get_namespace_count(chandle, &call);
    15011501                        break;
    15021502                case LOC_GET_SERVICE_COUNT:
    1503                         loc_get_service_count(callid, &call);
     1503                        loc_get_service_count(chandle, &call);
    15041504                        break;
    15051505                case LOC_GET_CATEGORIES:
    1506                         loc_get_categories(callid, &call);
     1506                        loc_get_categories(chandle, &call);
    15071507                        break;
    15081508                case LOC_GET_NAMESPACES:
    1509                         loc_get_namespaces(callid, &call);
     1509                        loc_get_namespaces(chandle, &call);
    15101510                        break;
    15111511                case LOC_GET_SERVICES:
    1512                         loc_get_services(callid, &call);
     1512                        loc_get_services(chandle, &call);
    15131513                        break;
    15141514                default:
    1515                         async_answer_0(callid, ENOENT);
     1515                        async_answer_0(chandle, ENOENT);
    15161516                }
    15171517        }
Note: See TracChangeset for help on using the changeset viewer.