Index: uspace/srv/locsrv/locsrv.c
===================================================================
--- uspace/srv/locsrv/locsrv.c	(revision 7c3fb9bd77e4d2f6c10517a052e567f176fa91ee)
+++ uspace/srv/locsrv/locsrv.c	(revision bd9e868109273fe333c36fad00976f58740dbb8b)
@@ -341,8 +341,8 @@
 {
 	ipc_call_t icall;
-	cap_call_handle_t icall_handle = async_get_call(&icall);
+	async_get_call(&icall);
 
 	if (IPC_GET_IMETHOD(icall) != LOC_SERVER_REGISTER) {
-		async_answer_0(icall_handle, EREFUSED);
+		async_answer_0(&icall, EREFUSED);
 		return NULL;
 	}
@@ -351,5 +351,5 @@
 	    (loc_server_t *) malloc(sizeof(loc_server_t));
 	if (server == NULL) {
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(&icall, ENOMEM);
 		return NULL;
 	}
@@ -362,5 +362,5 @@
 	if (rc != EOK) {
 		free(server);
-		async_answer_0(icall_handle, rc);
+		async_answer_0(&icall, rc);
 		return NULL;
 	}
@@ -373,5 +373,5 @@
 		free(server->name);
 		free(server);
-		async_answer_0(icall_handle, ENOTSUP);
+		async_answer_0(&icall, ENOTSUP);
 		return NULL;
 	}
@@ -403,5 +403,5 @@
 	fibril_mutex_unlock(&servers_list_mutex);
 
-	async_answer_0(icall_handle, EOK);
+	async_answer_0(&icall, EOK);
 
 	return server;
@@ -456,9 +456,8 @@
  *
  */
-static void loc_service_register(cap_call_handle_t icall_handle, ipc_call_t *icall,
-    loc_server_t *server)
+static void loc_service_register(ipc_call_t *icall, loc_server_t *server)
 {
 	if (server == NULL) {
-		async_answer_0(icall_handle, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -468,5 +467,5 @@
 	    (loc_service_t *) malloc(sizeof(loc_service_t));
 	if (service == NULL) {
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -478,5 +477,5 @@
 	if (rc != EOK) {
 		free(service);
-		async_answer_0(icall_handle, rc);
+		async_answer_0(icall, rc);
 		return;
 	}
@@ -486,5 +485,5 @@
 		free(fqsn);
 		free(service);
-		async_answer_0(icall_handle, EINVAL);
+		async_answer_0(icall, EINVAL);
 		return;
 	}
@@ -500,5 +499,5 @@
 		free(service->name);
 		free(service);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -516,5 +515,5 @@
 		free(service->name);
 		free(service);
-		async_answer_0(icall_handle, EEXIST);
+		async_answer_0(icall, EEXIST);
 		return;
 	}
@@ -538,5 +537,5 @@
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_1(icall_handle, EOK, service->id);
+	async_answer_1(icall, EOK, service->id);
 }
 
@@ -544,6 +543,5 @@
  *
  */
-static void loc_service_unregister(cap_call_handle_t icall_handle, ipc_call_t *icall,
-    loc_server_t *server)
+static void loc_service_unregister(ipc_call_t *icall, loc_server_t *server)
 {
 	loc_service_t *svc;
@@ -553,5 +551,5 @@
 	if (svc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -568,17 +566,17 @@
 	 */
 	loc_category_change_event();
-	async_answer_0(icall_handle, EOK);
-}
-
-static void loc_category_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
-{
-	cap_call_handle_t chandle;
+	async_answer_0(icall, EOK);
+}
+
+static void loc_category_get_name(ipc_call_t *icall)
+{
+	ipc_call_t call;
 	size_t size;
 	size_t act_size;
 	category_t *cat;
 
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -589,6 +587,6 @@
 	if (cat == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, ENOENT);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(&call, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -597,20 +595,20 @@
 	if (act_size > size) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, EOVERFLOW);
-		async_answer_0(icall_handle, EOVERFLOW);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(chandle, cat->name,
+		async_answer_0(&call, EOVERFLOW);
+		async_answer_0(icall, EOVERFLOW);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(&call, cat->name,
 	    min(size, act_size));
 
 	fibril_mutex_unlock(&cdir.mutex);
 
-	async_answer_0(icall_handle, retval);
-}
-
-static void loc_service_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
-{
-	cap_call_handle_t chandle;
+	async_answer_0(icall, retval);
+}
+
+static void loc_service_get_name(ipc_call_t *icall)
+{
+	ipc_call_t call;
 	size_t size;
 	size_t act_size;
@@ -618,7 +616,7 @@
 	char *fqn;
 
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -629,6 +627,6 @@
 	if (svc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOENT);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(&call, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -636,6 +634,6 @@
 	if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOMEM);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(&call, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -645,10 +643,10 @@
 		free(fqn);
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, EOVERFLOW);
-		async_answer_0(icall_handle, EOVERFLOW);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(chandle, fqn,
+		async_answer_0(&call, EOVERFLOW);
+		async_answer_0(icall, EOVERFLOW);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(&call, fqn,
 	    min(size, act_size));
 	free(fqn);
@@ -656,17 +654,17 @@
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(icall_handle, retval);
-}
-
-static void loc_service_get_server_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
-{
-	cap_call_handle_t chandle;
+	async_answer_0(icall, retval);
+}
+
+static void loc_service_get_server_name(ipc_call_t *icall)
+{
+	ipc_call_t call;
 	size_t size;
 	size_t act_size;
 	loc_service_t *svc;
 
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -677,6 +675,6 @@
 	if (svc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOENT);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(&call, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -684,6 +682,6 @@
 	if (svc->server == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, EINVAL);
-		async_answer_0(icall_handle, EINVAL);
+		async_answer_0(&call, EINVAL);
+		async_answer_0(icall, EINVAL);
 		return;
 	}
@@ -692,15 +690,15 @@
 	if (act_size > size) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, EOVERFLOW);
-		async_answer_0(icall_handle, EOVERFLOW);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(chandle, svc->server->name,
+		async_answer_0(&call, EOVERFLOW);
+		async_answer_0(icall, EOVERFLOW);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(&call, svc->server->name,
 	    min(size, act_size));
 
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(icall_handle, retval);
+	async_answer_0(icall, retval);
 }
 
@@ -711,5 +709,5 @@
  *
  */
-static void loc_forward(cap_call_handle_t chandle, ipc_call_t *call, void *arg)
+static void loc_forward(ipc_call_t *call, void *arg)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -724,10 +722,10 @@
 	if ((svc == NULL) || (svc->server == NULL) || (!svc->server->sess)) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOENT);
+		async_answer_0(call, ENOENT);
 		return;
 	}
 
 	async_exch_t *exch = async_exchange_begin(svc->server->sess);
-	async_forward_fast(chandle, exch, iface, svc->id, 0, IPC_FF_NONE);
+	async_forward_fast(call, exch, iface, svc->id, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 
@@ -741,5 +739,5 @@
  *
  */
-static void loc_service_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_service_get_id(ipc_call_t *icall)
 {
 	char *fqsn;
@@ -749,5 +747,5 @@
 	    LOC_NAME_MAXLEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(icall_handle, rc);
+		async_answer_0(icall, rc);
 		return;
 	}
@@ -757,5 +755,5 @@
 	if (!loc_fqsn_split(fqsn, &ns_name, &name)) {
 		free(fqsn);
-		async_answer_0(icall_handle, EINVAL);
+		async_answer_0(icall, EINVAL);
 		return;
 	}
@@ -784,5 +782,5 @@
 		}
 
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(icall, ENOENT);
 		free(ns_name);
 		free(name);
@@ -791,5 +789,5 @@
 	}
 
-	async_answer_1(icall_handle, EOK, svc->id);
+	async_answer_1(icall, EOK, svc->id);
 
 	fibril_mutex_unlock(&services_list_mutex);
@@ -804,5 +802,5 @@
  *
  */
-static void loc_namespace_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_namespace_get_id(ipc_call_t *icall)
 {
 	char *name;
@@ -812,5 +810,5 @@
 	    LOC_NAME_MAXLEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(icall_handle, rc);
+		async_answer_0(icall, rc);
 		return;
 	}
@@ -837,5 +835,5 @@
 		}
 
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(icall, ENOENT);
 		free(name);
 		fibril_mutex_unlock(&services_list_mutex);
@@ -843,5 +841,5 @@
 	}
 
-	async_answer_1(icall_handle, EOK, namespace->id);
+	async_answer_1(icall, EOK, namespace->id);
 
 	fibril_mutex_unlock(&services_list_mutex);
@@ -858,9 +856,9 @@
  *
  */
-static void loc_callback_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_callback_create(ipc_call_t *icall)
 {
 	cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
 	if (cb_sess == NULL) {
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -869,5 +867,5 @@
 	if (sess == NULL) {
 		free(cb_sess);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -880,5 +878,5 @@
 	fibril_mutex_unlock(&callback_sess_mutex);
 
-	async_answer_0(icall_handle, EOK);
+	async_answer_0(icall, EOK);
 }
 
@@ -902,5 +900,5 @@
  *
  */
-static void loc_category_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_category_get_id(ipc_call_t *icall)
 {
 	char *name;
@@ -911,5 +909,5 @@
 	    LOC_NAME_MAXLEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(icall_handle, rc);
+		async_answer_0(icall, rc);
 		return;
 	}
@@ -920,9 +918,9 @@
 	if (cat == NULL) {
 		/* Category not found */
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(icall, ENOENT);
 		goto cleanup;
 	}
 
-	async_answer_1(icall_handle, EOK, cat->id);
+	async_answer_1(icall, EOK, cat->id);
 cleanup:
 	fibril_mutex_unlock(&cdir.mutex);
@@ -930,5 +928,5 @@
 }
 
-static void loc_id_probe(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_id_probe(ipc_call_t *icall)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -940,21 +938,21 @@
 		    loc_service_find_id(IPC_GET_ARG1(*icall));
 		if (svc == NULL)
-			async_answer_1(icall_handle, EOK, LOC_OBJECT_NONE);
+			async_answer_1(icall, EOK, LOC_OBJECT_NONE);
 		else
-			async_answer_1(icall_handle, EOK, LOC_OBJECT_SERVICE);
+			async_answer_1(icall, EOK, LOC_OBJECT_SERVICE);
 	} else
-		async_answer_1(icall_handle, EOK, LOC_OBJECT_NAMESPACE);
+		async_answer_1(icall, EOK, LOC_OBJECT_NAMESPACE);
 
 	fibril_mutex_unlock(&services_list_mutex);
 }
 
-static void loc_get_namespace_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_get_namespace_count(ipc_call_t *icall)
 {
 	fibril_mutex_lock(&services_list_mutex);
-	async_answer_1(icall_handle, EOK, list_count(&namespaces_list));
+	async_answer_1(icall, EOK, list_count(&namespaces_list));
 	fibril_mutex_unlock(&services_list_mutex);
 }
 
-static void loc_get_service_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
+static void loc_get_service_count(ipc_call_t *icall)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -963,21 +961,21 @@
 	    loc_namespace_find_id(IPC_GET_ARG1(*icall));
 	if (namespace == NULL)
-		async_answer_0(icall_handle, EEXIST);
+		async_answer_0(icall, EEXIST);
 	else
-		async_answer_1(icall_handle, EOK, namespace->refcnt);
+		async_answer_1(icall, EOK, namespace->refcnt);
 
 	fibril_mutex_unlock(&services_list_mutex);
 }
 
-static void loc_get_categories(cap_call_handle_t icall_handle, ipc_call_t *icall)
-{
-	cap_call_handle_t chandle;
+static void loc_get_categories(ipc_call_t *icall)
+{
+	ipc_call_t call;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -986,6 +984,6 @@
 	if (id_buf == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, ENOMEM);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(&call, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -996,6 +994,6 @@
 	if (rc != EOK) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, rc);
-		async_answer_0(icall_handle, rc);
+		async_answer_0(&call, rc);
+		async_answer_0(icall, rc);
 		return;
 	}
@@ -1003,23 +1001,23 @@
 	fibril_mutex_unlock(&cdir.mutex);
 
-	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
+	errno_t retval = async_data_read_finalize(&call, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(icall_handle, retval, act_size);
-}
-
-static void loc_get_namespaces(cap_call_handle_t icall_handle, ipc_call_t *icall)
-{
-	cap_call_handle_t chandle;
+	async_answer_1(icall, retval, act_size);
+}
+
+static void loc_get_namespaces(ipc_call_t *icall)
+{
+	ipc_call_t call;
 	size_t size;
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
 
 	if ((size % sizeof(loc_sdesc_t)) != 0) {
-		async_answer_0(chandle, EINVAL);
-		async_answer_0(icall_handle, EINVAL);
+		async_answer_0(&call, EINVAL);
+		async_answer_0(icall, EINVAL);
 		return;
 	}
@@ -1030,6 +1028,6 @@
 	if (count != list_count(&namespaces_list)) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, EOVERFLOW);
-		async_answer_0(icall_handle, EOVERFLOW);
+		async_answer_0(&call, EOVERFLOW);
+		async_answer_0(icall, EOVERFLOW);
 		return;
 	}
@@ -1038,6 +1036,6 @@
 	if (desc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOMEM);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(&call, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -1050,13 +1048,13 @@
 	}
 
-	errno_t retval = async_data_read_finalize(chandle, desc, size);
+	errno_t retval = async_data_read_finalize(&call, desc, size);
 
 	free(desc);
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(icall_handle, retval);
-}
-
-static void loc_get_services(cap_call_handle_t icall_handle, ipc_call_t *icall)
+	async_answer_0(icall, retval);
+}
+
+static void loc_get_services(ipc_call_t *icall)
 {
 	/*
@@ -1065,15 +1063,15 @@
 	 */
 
-	cap_call_handle_t chandle;
+	ipc_call_t call;
 	size_t size;
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
 
 	if ((size % sizeof(loc_sdesc_t)) != 0) {
-		async_answer_0(chandle, EINVAL);
-		async_answer_0(icall_handle, EINVAL);
+		async_answer_0(&call, EINVAL);
+		async_answer_0(icall, EINVAL);
 		return;
 	}
@@ -1085,6 +1083,6 @@
 	if (namespace == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOENT);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(&call, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -1093,6 +1091,6 @@
 	if (count != namespace->refcnt) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, EOVERFLOW);
-		async_answer_0(icall_handle, EOVERFLOW);
+		async_answer_0(&call, EOVERFLOW);
+		async_answer_0(icall, EOVERFLOW);
 		return;
 	}
@@ -1101,6 +1099,6 @@
 	if (desc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(chandle, ENOMEM);
-		async_answer_0(icall_handle, EREFUSED);
+		async_answer_0(&call, ENOMEM);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -1115,22 +1113,22 @@
 	}
 
-	errno_t retval = async_data_read_finalize(chandle, desc, size);
+	errno_t retval = async_data_read_finalize(&call, desc, size);
 
 	free(desc);
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(icall_handle, retval);
-}
-
-static void loc_category_get_svcs(cap_call_handle_t icall_handle, ipc_call_t *icall)
-{
-	cap_call_handle_t chandle;
+	async_answer_0(icall, retval);
+}
+
+static void loc_category_get_svcs(ipc_call_t *icall)
+{
+	ipc_call_t call;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&chandle, &size)) {
-		async_answer_0(chandle, EREFUSED);
-		async_answer_0(icall_handle, EREFUSED);
+	if (!async_data_read_receive(&call, &size)) {
+		async_answer_0(&call, EREFUSED);
+		async_answer_0(icall, EREFUSED);
 		return;
 	}
@@ -1141,6 +1139,6 @@
 	if (cat == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, ENOENT);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(&call, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -1149,6 +1147,6 @@
 	if (id_buf == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, ENOMEM);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(&call, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -1160,6 +1158,6 @@
 		fibril_mutex_unlock(&cat->mutex);
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(chandle, rc);
-		async_answer_0(icall_handle, rc);
+		async_answer_0(&call, rc);
+		async_answer_0(icall, rc);
 		return;
 	}
@@ -1168,12 +1166,12 @@
 	fibril_mutex_unlock(&cdir.mutex);
 
-	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
+	errno_t retval = async_data_read_finalize(&call, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(icall_handle, retval, act_size);
-}
-
-
-static void loc_null_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
+	async_answer_1(icall, retval, act_size);
+}
+
+
+static void loc_null_create(ipc_call_t *icall)
 {
 	fibril_mutex_lock(&null_services_mutex);
@@ -1191,5 +1189,5 @@
 	if (!fnd) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -1201,5 +1199,5 @@
 	if (dev_name == NULL) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -1209,5 +1207,5 @@
 	if (service == NULL) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -1219,5 +1217,5 @@
 		fibril_mutex_lock(&services_list_mutex);
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(icall_handle, ENOMEM);
+		async_answer_0(icall, ENOMEM);
 		return;
 	}
@@ -1246,12 +1244,12 @@
 	fibril_mutex_unlock(&null_services_mutex);
 
-	async_answer_1(icall_handle, EOK, (sysarg_t) i);
-}
-
-static void loc_null_destroy(cap_call_handle_t icall_handle, ipc_call_t *icall)
+	async_answer_1(icall, EOK, (sysarg_t) i);
+}
+
+static void loc_null_destroy(ipc_call_t *icall)
 {
 	sysarg_t i = IPC_GET_ARG1(*icall);
 	if (i >= NULL_SERVICES) {
-		async_answer_0(icall_handle, ELIMIT);
+		async_answer_0(icall, ELIMIT);
 		return;
 	}
@@ -1261,5 +1259,5 @@
 	if (null_services[i] == NULL) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -1274,8 +1272,8 @@
 
 	fibril_mutex_unlock(&null_services_mutex);
-	async_answer_0(icall_handle, EOK);
-}
-
-static void loc_service_add_to_cat(cap_call_handle_t icall_handle, ipc_call_t *icall)
+	async_answer_0(icall, EOK);
+}
+
+static void loc_service_add_to_cat(ipc_call_t *icall)
 {
 	category_t *cat;
@@ -1297,5 +1295,5 @@
 		fibril_mutex_unlock(&cdir.mutex);
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(icall_handle, ENOENT);
+		async_answer_0(icall, ENOENT);
 		return;
 	}
@@ -1314,5 +1312,5 @@
 	 */
 	loc_category_change_event();
-	async_answer_0(icall_handle, retval);
+	async_answer_0(icall, retval);
 }
 
@@ -1398,8 +1396,8 @@
  *
  */
-static void loc_connection_supplier(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+static void loc_connection_supplier(ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
-	async_answer_0(icall_handle, EOK);
+	async_answer_0(icall, EOK);
 
 	loc_server_t *server = loc_server_register();
@@ -1409,5 +1407,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t chandle = async_get_call(&call);
+		async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -1417,28 +1415,28 @@
 		case LOC_SERVER_UNREGISTER:
 			if (server == NULL)
-				async_answer_0(chandle, ENOENT);
+				async_answer_0(&call, ENOENT);
 			else
-				async_answer_0(chandle, EOK);
+				async_answer_0(&call, EOK);
 			break;
 		case LOC_SERVICE_ADD_TO_CAT:
 			/* Add service to category */
-			loc_service_add_to_cat(chandle, &call);
+			loc_service_add_to_cat(&call);
 			break;
 		case LOC_SERVICE_REGISTER:
 			/* Register one service */
-			loc_service_register(chandle, &call, server);
+			loc_service_register(&call, server);
 			break;
 		case LOC_SERVICE_UNREGISTER:
 			/* Remove one service */
-			loc_service_unregister(chandle, &call, server);
+			loc_service_unregister(&call, server);
 			break;
 		case LOC_SERVICE_GET_ID:
-			loc_service_get_id(chandle, &call);
+			loc_service_get_id(&call);
 			break;
 		case LOC_NAMESPACE_GET_ID:
-			loc_namespace_get_id(chandle, &call);
+			loc_namespace_get_id(&call);
 			break;
 		default:
-			async_answer_0(chandle, ENOENT);
+			async_answer_0(&call, ENOENT);
 		}
 	}
@@ -1456,12 +1454,12 @@
  *
  */
-static void loc_connection_consumer(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+static void loc_connection_consumer(ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
-	async_answer_0(icall_handle, EOK);
+	async_answer_0(icall, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t chandle = async_get_call(&call);
+		async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -1470,53 +1468,53 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case LOC_SERVICE_GET_ID:
-			loc_service_get_id(chandle, &call);
+			loc_service_get_id(&call);
 			break;
 		case LOC_SERVICE_GET_NAME:
-			loc_service_get_name(chandle, &call);
+			loc_service_get_name(&call);
 			break;
 		case LOC_SERVICE_GET_SERVER_NAME:
-			loc_service_get_server_name(chandle, &call);
+			loc_service_get_server_name(&call);
 			break;
 		case LOC_NAMESPACE_GET_ID:
-			loc_namespace_get_id(chandle, &call);
+			loc_namespace_get_id(&call);
 			break;
 		case LOC_CALLBACK_CREATE:
-			loc_callback_create(chandle, &call);
+			loc_callback_create(&call);
 			break;
 		case LOC_CATEGORY_GET_ID:
-			loc_category_get_id(chandle, &call);
+			loc_category_get_id(&call);
 			break;
 		case LOC_CATEGORY_GET_NAME:
-			loc_category_get_name(chandle, &call);
+			loc_category_get_name(&call);
 			break;
 		case LOC_CATEGORY_GET_SVCS:
-			loc_category_get_svcs(chandle, &call);
+			loc_category_get_svcs(&call);
 			break;
 		case LOC_ID_PROBE:
-			loc_id_probe(chandle, &call);
+			loc_id_probe(&call);
 			break;
 		case LOC_NULL_CREATE:
-			loc_null_create(chandle, &call);
+			loc_null_create(&call);
 			break;
 		case LOC_NULL_DESTROY:
-			loc_null_destroy(chandle, &call);
+			loc_null_destroy(&call);
 			break;
 		case LOC_GET_NAMESPACE_COUNT:
-			loc_get_namespace_count(chandle, &call);
+			loc_get_namespace_count(&call);
 			break;
 		case LOC_GET_SERVICE_COUNT:
-			loc_get_service_count(chandle, &call);
+			loc_get_service_count(&call);
 			break;
 		case LOC_GET_CATEGORIES:
-			loc_get_categories(chandle, &call);
+			loc_get_categories(&call);
 			break;
 		case LOC_GET_NAMESPACES:
-			loc_get_namespaces(chandle, &call);
+			loc_get_namespaces(&call);
 			break;
 		case LOC_GET_SERVICES:
-			loc_get_services(chandle, &call);
+			loc_get_services(&call);
 			break;
 		default:
-			async_answer_0(chandle, ENOENT);
+			async_answer_0(&call, ENOENT);
 		}
 	}
