Index: contrib/arch/kernel/kernel.adl
===================================================================
--- contrib/arch/kernel/kernel.adl	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ contrib/arch/kernel/kernel.adl	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -115,14 +115,14 @@
 
 		/* Fast forward a received IPC call to another destination */
-		sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid, sysarg_t method, sysarg_t arg1, sysarg_t arg2, int mode);
+		sysarg_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phoneid, sysarg_t method, sysarg_t arg1, sysarg_t arg2, int mode);
 
 		/* Slow forward a received IPC call to another destination */
-		sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid, ipc_data_t *data, int mode);
+		sysarg_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phoneid, ipc_data_t *data, int mode);
 
 		/* Fast answer an IPC call */
-		sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4);
+		sysarg_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4);
 
 		/* Slow answer an IPC call */
-		sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data);
+		sysarg_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data);
 
 		/* Hang up a phone */
Index: uspace/app/wavplay/dplay.c
===================================================================
--- uspace/app/wavplay/dplay.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/app/wavplay/dplay.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -90,21 +90,23 @@
 /**
  * Fragment playback callback function.
- * @param iid IPC call id.
- * @param icall Pointer to the call structure
- * @param arg Argument, pointer to the playback helper function
- */
-static void device_event_callback(cap_call_handle_t iid, ipc_call_t *icall, void* arg)
-{
-	async_answer_0(iid, EOK);
+ *
+ * @param icall_handle  Call capability handle.
+ * @param icall         Pointer to the call structure
+ * @param arg           Argument, pointer to the playback helper function
+ */
+static void device_event_callback(cap_call_handle_t icall_handle,
+    ipc_call_t *icall, void *arg)
+{
+	async_answer_0(icall_handle, EOK);
 	playback_t *pb = arg;
 	const size_t fragment_size = pb->buffer.size / DEFAULT_FRAGMENTS;
 	while (1) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		switch(IPC_GET_IMETHOD(call)) {
 		case PCM_EVENT_PLAYBACK_STARTED:
 		case PCM_EVENT_FRAMES_PLAYED:
 			printf("%" PRIun " frames: ", IPC_GET_ARG1(call));
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		case PCM_EVENT_PLAYBACK_TERMINATED:
@@ -113,10 +115,10 @@
 			pb->playing = false;
 			fibril_condvar_signal(&pb->cv);
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			fibril_mutex_unlock(&pb->mutex);
 			return;
 		default:
 			printf("Unknown event %" PRIun ".\n", IPC_GET_IMETHOD(call));
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			continue;
 
Index: uspace/app/wavplay/drec.c
===================================================================
--- uspace/app/wavplay/drec.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/app/wavplay/drec.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -86,12 +86,16 @@
 
 /**
- * Recording callback. Writes recorded data.
- * @param iid IPC call id.
- * @param icall Poitner to IPC call structure.
- * @param arg Argument. Poitner to recording helper structure.
- */
-static void device_event_callback(cap_call_handle_t iid, ipc_call_t *icall, void* arg)
-{
-	async_answer_0(iid, EOK);
+ * Recording callback.
+ *
+ * Writes recorded data.
+ * 
+ * @param icall_handle  IPC call id.
+ * @param icall         Poitner to IPC call structure.
+ * @param arg           Argument. Poitner to recording helper structure.
+ */
+static void device_event_callback(cap_call_handle_t icall_handle,
+    ipc_call_t *icall, void *arg)
+{
+	async_answer_0(icall_handle, EOK);
 	record_t *rec = arg;
 	const size_t buffer_part = rec->buffer.size / BUFFER_PARTS;
@@ -99,5 +103,5 @@
 	while (record) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		switch(IPC_GET_IMETHOD(call)) {
 		case PCM_EVENT_CAPTURE_TERMINATED:
@@ -110,10 +114,10 @@
 		default:
 			printf("Unknown event %" PRIun ".\n", IPC_GET_IMETHOD(call));
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			continue;
 		}
 
 		if (!record) {
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -127,5 +131,5 @@
 		if (rec->buffer.position >= (rec->buffer.base + rec->buffer.size))
 			rec->buffer.position = rec->buffer.base;
-		async_answer_0(callid, EOK);
+		async_answer_0(chandle, EOK);
 	}
 }
Index: uspace/drv/block/ata_bd/main.c
===================================================================
--- uspace/drv/block/ata_bd/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/block/ata_bd/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -313,10 +313,10 @@
 
 /** Block device connection handler */
-static void ata_bd_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void ata_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ata_fun_t *afun;
 
 	afun = (ata_fun_t *) ddf_fun_data_get((ddf_fun_t *)arg);
-	bd_conn(iid, icall, &afun->bds);
+	bd_conn(icall_handle, icall, &afun->bds);
 }
 
Index: uspace/drv/block/ddisk/ddisk.c
===================================================================
--- uspace/drv/block/ddisk/ddisk.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/block/ddisk/ddisk.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -587,5 +587,5 @@
 
 /** Block device connection handler */
-static void ddisk_bd_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void ddisk_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ddisk_t *ddisk;
@@ -593,5 +593,5 @@
 
 	ddisk = (ddisk_t *) ddf_dev_data_get(ddf_fun_get_dev(fun));
-	bd_conn(iid, icall, &ddisk->bds);
+	bd_conn(icall_handle, icall, &ddisk->bds);
 }
 
Index: uspace/drv/block/usbmast/main.c
===================================================================
--- uspace/drv/block/usbmast/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/block/usbmast/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -79,5 +79,5 @@
 
 static errno_t usbmast_fun_create(usbmast_dev_t *mdev, unsigned lun);
-static void usbmast_bd_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void usbmast_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg);
 
@@ -317,5 +317,5 @@
 
 /** Blockdev client connection handler. */
-static void usbmast_bd_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void usbmast_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -323,5 +323,5 @@
 
 	mfun = (usbmast_fun_t *) ddf_fun_data_get((ddf_fun_t *)arg);
-	bd_conn(iid, icall, &mfun->bds);
+	bd_conn(icall_handle, icall, &mfun->bds);
 }
 
Index: uspace/drv/bus/adb/cuda_adb/cuda_adb.c
===================================================================
--- uspace/drv/bus/adb/cuda_adb/cuda_adb.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/bus/adb/cuda_adb/cuda_adb.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -198,21 +198,22 @@
 
 /** Device connection handler */
-static void cuda_dev_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void cuda_dev_connection(cap_call_handle_t icall_handle,
+    ipc_call_t *icall, void *arg)
 {
 	adb_dev_t *dev = (adb_dev_t *) ddf_fun_data_get((ddf_fun_t *) arg);
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	sysarg_t method;
 
 	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -222,7 +223,7 @@
 		if (sess != NULL) {
 			dev->client_sess = sess;
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 		} else {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/drv/bus/usb/vhc/conndev.c
===================================================================
--- uspace/drv/bus/usb/vhc/conndev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/bus/usb/vhc/conndev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -90,8 +90,8 @@
  *
  * @param fun Device handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall Call data.
  */
-void default_connection_handler(ddf_fun_t *fun, cap_call_handle_t icallid,
+void default_connection_handler(ddf_fun_t *fun, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -104,10 +104,10 @@
 		errno_t rc = vhc_virtdev_plug(vhc, callback, &plugged_device_handle);
 		if (rc != EOK) {
-			async_answer_0(icallid, rc);
+			async_answer_0(icall_handle, rc);
 			async_hangup(callback);
 			return;
 		}
 
-		async_answer_0(icallid, EOK);
+		async_answer_0(icall_handle, EOK);
 
 		receive_device_name(callback);
@@ -116,5 +116,5 @@
 		    plugged_device_name, plugged_device_handle);
 	} else
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 }
 
Index: uspace/drv/bus/usb/vhc/vhcd.h
===================================================================
--- uspace/drv/bus/usb/vhc/vhcd.h	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/bus/usb/vhc/vhcd.h	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -88,5 +88,5 @@
 
 void on_client_close(ddf_fun_t *fun);
-void default_connection_handler(ddf_fun_t *fun, cap_call_handle_t icallid,
+void default_connection_handler(ddf_fun_t *fun, cap_call_handle_t icall_handle,
     ipc_call_t *icall);
 
Index: uspace/drv/char/i8042/i8042.c
===================================================================
--- uspace/drv/char/i8042/i8042.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/char/i8042/i8042.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -414,13 +414,13 @@
 /** Handle data requests.
  *
- * @param id   callid
+ * @param id   chandle
  * @param call IPC request.
  * @param arg  ddf_fun_t function.
  */
-void i8042_char_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void i8042_char_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	i8042_port_t *port = ddf_fun_data_get((ddf_fun_t *)arg);
 
-	chardev_conn(iid, icall, &port->cds);
+	chardev_conn(icall_handle, icall, &port->cds);
 }
 
Index: uspace/drv/char/msim-con/msim-con.c
===================================================================
--- uspace/drv/char/msim-con/msim-con.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/char/msim-con/msim-con.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -217,5 +217,5 @@
 
 /** Character device connection handler. */
-static void msim_con_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void msim_con_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -223,5 +223,5 @@
 	    ddf_fun_get_dev((ddf_fun_t *) arg));
 
-	chardev_conn(iid, icall, &con->cds);
+	chardev_conn(icall_handle, icall, &con->cds);
 }
 
Index: uspace/drv/char/ns8250/ns8250.c
===================================================================
--- uspace/drv/char/ns8250/ns8250.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/char/ns8250/ns8250.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1068,5 +1068,5 @@
  * Configure the parameters of the serial communication.
  */
-static void ns8250_default_handler(chardev_srv_t *srv, cap_call_handle_t callid,
+static void ns8250_default_handler(chardev_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -1080,5 +1080,5 @@
 		ns8250_get_props(ns8250->dev, &baud_rate, &parity, &word_length,
 		    &stop_bits);
-		async_answer_4(callid, EOK, baud_rate, parity, word_length,
+		async_answer_4(chandle, EOK, baud_rate, parity, word_length,
 		    stop_bits);
 		break;
@@ -1091,17 +1091,17 @@
 		ret = ns8250_set_props(ns8250->dev, baud_rate, parity, word_length,
 		    stop_bits);
-		async_answer_0(callid, ret);
+		async_answer_0(chandle, ret);
 		break;
 
 	default:
-		async_answer_0(callid, ENOTSUP);
-	}
-}
-
-void ns8250_char_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+		async_answer_0(chandle, ENOTSUP);
+	}
+}
+
+void ns8250_char_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ns8250_t *ns8250 = fun_ns8250((ddf_fun_t *)arg);
 
-	chardev_conn(iid, icall, &ns8250->cds);
+	chardev_conn(icall_handle, icall, &ns8250->cds);
 }
 
Index: uspace/drv/char/pl050/pl050.c
===================================================================
--- uspace/drv/char/pl050/pl050.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/char/pl050/pl050.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -286,9 +286,9 @@
 }
 
-void pl050_char_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void pl050_char_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	pl050_t *pl050 = pl050_from_fun((ddf_fun_t *)arg);
 
-	chardev_conn(iid, icall, &pl050->cds);
+	chardev_conn(icall_handle, icall, &pl050->cds);
 }
 
Index: uspace/drv/char/ski-con/ski-con.c
===================================================================
--- uspace/drv/char/ski-con/ski-con.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/char/ski-con/ski-con.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -255,5 +255,5 @@
 
 /** Character device connection handler. */
-static void ski_con_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void ski_con_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -261,5 +261,5 @@
 	    ddf_fun_get_dev((ddf_fun_t *) arg));
 
-	chardev_conn(iid, icall, &con->cds);
+	chardev_conn(icall_handle, icall, &con->cds);
 }
 
Index: uspace/drv/char/sun4v-con/sun4v-con.c
===================================================================
--- uspace/drv/char/sun4v-con/sun4v-con.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/char/sun4v-con/sun4v-con.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -180,5 +180,5 @@
 
 /** Character device connection handler. */
-static void sun4v_con_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void sun4v_con_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -186,5 +186,5 @@
 	    ddf_fun_get_dev((ddf_fun_t *) arg));
 
-	chardev_conn(iid, icall, &con->cds);
+	chardev_conn(icall_handle, icall, &con->cds);
 }
 
Index: uspace/drv/fb/amdm37x_dispc/main.c
===================================================================
--- uspace/drv/fb/amdm37x_dispc/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/fb/amdm37x_dispc/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -46,10 +46,10 @@
 #define NAME  "amdm37x_dispc"
 
-static void graph_vsl_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void graph_vsl_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	visualizer_t *vsl;
 
 	vsl = (visualizer_t *) ddf_fun_data_get((ddf_fun_t *)arg);
-	graph_visualizer_connection(vsl, iid, icall, NULL);
+	graph_visualizer_connection(vsl, icall_handle, icall, NULL);
 }
 
Index: uspace/drv/fb/kfb/port.c
===================================================================
--- uspace/drv/fb/kfb/port.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/fb/kfb/port.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -162,5 +162,5 @@
 };
 
-static void graph_vsl_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void graph_vsl_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	visualizer_t *vsl;
@@ -168,5 +168,5 @@
 
 	vsl = (visualizer_t *) ddf_fun_data_get((ddf_fun_t *)arg);
-	graph_visualizer_connection(vsl, iid, icall, NULL);
+	graph_visualizer_connection(vsl, icall_handle, icall, NULL);
 
 	if (kfb.addr != NULL) {
Index: uspace/drv/hid/adb-kbd/adb-kbd.c
===================================================================
--- uspace/drv/hid/adb-kbd/adb-kbd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/adb-kbd/adb-kbd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -130,5 +130,5 @@
 }
 
-static void adb_kbd_events(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void adb_kbd_events(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	adb_kbd_t *kbd = (adb_kbd_t *) arg;
@@ -138,5 +138,5 @@
 
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		errno_t retval = EOK;
@@ -154,5 +154,5 @@
 			retval = ENOENT;
 		}
-		async_answer_0(callid, retval);
+		async_answer_0(chandle, retval);
 	}
 }
@@ -190,7 +190,7 @@
 
 /** Handle client connection */
-static void adb_kbd_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	cap_call_handle_t callid;
+static void adb_kbd_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	sysarg_t method;
@@ -200,15 +200,15 @@
 	 * Answer the first IPC_M_CONNECT_ME_TO call.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	kbd = (adb_kbd_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
 
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -218,7 +218,7 @@
 		if (sess != NULL) {
 			kbd->client_sess = sess;
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 		} else {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/drv/hid/adb-mouse/adb-mouse.c
===================================================================
--- uspace/drv/hid/adb-mouse/adb-mouse.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/adb-mouse/adb-mouse.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -88,5 +88,5 @@
 }
 
-static void adb_mouse_events(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void adb_mouse_events(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	adb_mouse_t *mouse = (adb_mouse_t *) arg;
@@ -95,5 +95,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		errno_t retval = EOK;
@@ -112,5 +112,5 @@
 		}
 
-		async_answer_0(callid, retval);
+		async_answer_0(chandle, retval);
 	}
 }
@@ -200,7 +200,7 @@
 
 /** Handle client connection */
-static void adb_mouse_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	cap_call_handle_t callid;
+static void adb_mouse_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	sysarg_t method;
@@ -210,15 +210,15 @@
 	 * Answer the first IPC_M_CONNECT_ME_TO call.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	mouse = (adb_mouse_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
 
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -228,7 +228,7 @@
 		if (sess != NULL) {
 			mouse->client_sess = sess;
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 		} else {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/drv/hid/atkbd/atkbd.c
===================================================================
--- uspace/drv/hid/atkbd/atkbd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/atkbd/atkbd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -293,10 +293,10 @@
  *
  * @param fun     Device function handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall   Call data.
  *
  */
 static void default_connection_handler(ddf_fun_t *fun,
-    cap_call_handle_t icallid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	const sysarg_t method = IPC_GET_IMETHOD(*icall);
@@ -306,5 +306,5 @@
 	switch (method) {
 	case KBDEV_SET_IND:
-		async_answer_0(icallid, ENOTSUP);
+		async_answer_0(icall_handle, ENOTSUP);
 		break;
 	/*
@@ -319,5 +319,5 @@
 			ddf_msg(LVL_WARN,
 			    "Failed creating callback session");
-			async_answer_0(icallid, EAGAIN);
+			async_answer_0(icall_handle, EAGAIN);
 			break;
 		}
@@ -326,8 +326,8 @@
 			kbd->client_sess = sess;
 			ddf_msg(LVL_DEBUG, "Set client session");
-			async_answer_0(icallid, EOK);
+			async_answer_0(icall_handle, EOK);
 		} else {
 			ddf_msg(LVL_ERROR, "Client session already set");
-			async_answer_0(icallid, ELIMIT);
+			async_answer_0(icall_handle, ELIMIT);
 		}
 
@@ -335,5 +335,5 @@
 	default:
 		ddf_msg(LVL_ERROR, "Unknown method: %d.", (int)method);
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		break;
 	}
Index: uspace/drv/hid/ps2mouse/ps2mouse.c
===================================================================
--- uspace/drv/hid/ps2mouse/ps2mouse.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/ps2mouse/ps2mouse.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -400,9 +400,9 @@
  *
  * @param fun Device function handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall Call data.
  */
 void default_connection_handler(ddf_fun_t *fun,
-    cap_call_handle_t icallid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	const sysarg_t method = IPC_GET_IMETHOD(*icall);
@@ -419,5 +419,5 @@
 			ddf_msg(LVL_WARN,
 			    "Failed creating client callback session");
-			async_answer_0(icallid, EAGAIN);
+			async_answer_0(icall_handle, EAGAIN);
 			break;
 		}
@@ -425,13 +425,13 @@
 			mouse->client_sess = sess;
 			ddf_msg(LVL_DEBUG, "Set client session");
-			async_answer_0(icallid, EOK);
+			async_answer_0(icall_handle, EOK);
 		} else {
 			ddf_msg(LVL_ERROR, "Client session already set");
-			async_answer_0(icallid, ELIMIT);
+			async_answer_0(icall_handle, ELIMIT);
 		}
 		break;
 	default:
 		ddf_msg(LVL_ERROR, "Unknown method: %d.", (int)method);
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		break;
 	}
Index: uspace/drv/hid/usbhid/kbd/kbddev.c
===================================================================
--- uspace/drv/hid/usbhid/kbd/kbddev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/usbhid/kbd/kbddev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -157,9 +157,9 @@
  *
  * @param fun Device function handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall Call data.
  */
 static void default_connection_handler(ddf_fun_t *fun,
-    cap_call_handle_t icallid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	const sysarg_t method = IPC_GET_IMETHOD(*icall);
@@ -171,5 +171,5 @@
 		kbd_dev->mods = IPC_GET_ARG1(*icall);
 		usb_kbd_set_led(kbd_dev->hid_dev, kbd_dev);
-		async_answer_0(icallid, EOK);
+		async_answer_0(icall_handle, EOK);
 		break;
 	/* This might be ugly but async_callback_receive_start makes no
@@ -181,5 +181,5 @@
 			usb_log_warning(
 			    "Failed to create start console session.\n");
-			async_answer_0(icallid, EAGAIN);
+			async_answer_0(icall_handle, EAGAIN);
 			break;
 		}
@@ -187,9 +187,9 @@
 			kbd_dev->client_sess = sess;
 			usb_log_debug("%s: OK", __FUNCTION__);
-			async_answer_0(icallid, EOK);
+			async_answer_0(icall_handle, EOK);
 		} else {
 			usb_log_error("%s: console session already set",
 			   __FUNCTION__);
-			async_answer_0(icallid, ELIMIT);
+			async_answer_0(icall_handle, ELIMIT);
 		}
 		break;
@@ -197,5 +197,5 @@
 			usb_log_error("%s: Unknown method: %d.",
 			    __FUNCTION__, (int) method);
-			async_answer_0(icallid, EINVAL);
+			async_answer_0(icall_handle, EINVAL);
 			break;
 	}
Index: uspace/drv/hid/usbhid/mouse/mousedev.c
===================================================================
--- uspace/drv/hid/usbhid/mouse/mousedev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/usbhid/mouse/mousedev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -110,9 +110,9 @@
  *
  * @param fun Device function handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall Call data.
  */
 static void default_connection_handler(ddf_fun_t *fun,
-    cap_call_handle_t icallid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	usb_mouse_t *mouse_dev = ddf_fun_data_get(fun);
@@ -120,5 +120,5 @@
 	if (mouse_dev == NULL) {
 		usb_log_debug("%s: Missing parameters.", __FUNCTION__);
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -135,14 +135,14 @@
 			usb_log_debug("Console session to %s set ok (%p).",
 			    ddf_fun_get_name(fun), sess);
-			async_answer_0(icallid, EOK);
+			async_answer_0(icall_handle, EOK);
 		} else {
 			usb_log_error("Console session to %s already set.",
 			    ddf_fun_get_name(fun));
-			async_answer_0(icallid, ELIMIT);
+			async_answer_0(icall_handle, ELIMIT);
 			async_hangup(sess);
 		}
 	} else {
 		usb_log_debug("%s: Invalid function.", __FUNCTION__);
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 	}
 }
Index: uspace/drv/hid/usbhid/multimedia/multimedia.c
===================================================================
--- uspace/drv/hid/usbhid/multimedia/multimedia.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/usbhid/multimedia/multimedia.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -81,9 +81,9 @@
  *
  * @param fun Device function handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall Call data.
  */
 static void default_connection_handler(ddf_fun_t *fun,
-    cap_call_handle_t icallid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	usb_log_debug(NAME " default_connection_handler()");
@@ -98,9 +98,9 @@
 			usb_log_debug(NAME " Saved session to console: %p",
 			    sess);
-			async_answer_0(icallid, EOK);
+			async_answer_0(icall_handle, EOK);
 		} else
-			async_answer_0(icallid, ELIMIT);
+			async_answer_0(icall_handle, ELIMIT);
 	} else
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 }
 
Index: uspace/drv/hid/xtkbd/xtkbd.c
===================================================================
--- uspace/drv/hid/xtkbd/xtkbd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/hid/xtkbd/xtkbd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -329,10 +329,10 @@
  *
  * @param fun     Device function handling the call.
- * @param icallid Call id.
+ * @param icall_handle Call id.
  * @param icall   Call data.
  *
  */
 static void default_connection_handler(ddf_fun_t *fun,
-    cap_call_handle_t icallid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	const sysarg_t method = IPC_GET_IMETHOD(*icall);
@@ -357,10 +357,10 @@
 		errno_t rc = chardev_write(kbd->chardev, &cmds[0], 1, &nwr);
 		if (rc != EOK) {
-			async_answer_0(icallid, rc);
+			async_answer_0(icall_handle, rc);
 			break;
 		}
 
 		rc = chardev_write(kbd->chardev, &cmds[1], 1, &nwr);
-		async_answer_0(icallid, rc);
+		async_answer_0(icall_handle, rc);
 		break;
 	/*
@@ -375,5 +375,5 @@
 			ddf_msg(LVL_WARN,
 			    "Failed creating callback session");
-			async_answer_0(icallid, EAGAIN);
+			async_answer_0(icall_handle, EAGAIN);
 			break;
 		}
@@ -382,8 +382,8 @@
 			kbd->client_sess = sess;
 			ddf_msg(LVL_DEBUG, "Set client session");
-			async_answer_0(icallid, EOK);
+			async_answer_0(icall_handle, EOK);
 		} else {
 			ddf_msg(LVL_ERROR, "Client session already set");
-			async_answer_0(icallid, ELIMIT);
+			async_answer_0(icall_handle, ELIMIT);
 		}
 
@@ -391,5 +391,5 @@
 	default:
 		ddf_msg(LVL_ERROR, "Unknown method: %d.", (int)method);
-		async_answer_0(icallid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		break;
 	}
Index: uspace/drv/intctl/apic/apic.c
===================================================================
--- uspace/drv/intctl/apic/apic.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/intctl/apic/apic.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -164,7 +164,7 @@
  * @param arg	Local argument.
  */
-static void apic_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	cap_call_handle_t callid;
+static void apic_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	apic_t *apic;
@@ -173,14 +173,14 @@
 	 * Answer the first IPC_M_CONNECT_ME_TO call.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	apic = (apic_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
 
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
 			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -188,17 +188,17 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case IRC_ENABLE_INTERRUPT:
-			async_answer_0(callid, apic_enable_irq(apic,
+			async_answer_0(chandle, apic_enable_irq(apic,
 			    IPC_GET_ARG1(call)));
 			break;
 		case IRC_DISABLE_INTERRUPT:
 			/* XXX TODO */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		case IRC_CLEAR_INTERRUPT:
 			/* Noop */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/drv/intctl/i8259/i8259.c
===================================================================
--- uspace/drv/intctl/i8259/i8259.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/intctl/i8259/i8259.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -93,7 +93,7 @@
  * @param arg	Local argument.
  */
-static void i8259_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	cap_call_handle_t callid;
+static void i8259_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	i8259_t *i8259 = NULL /* XXX */;
@@ -102,14 +102,14 @@
 	 * Answer the first IPC_M_CONNECT_ME_TO call.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	i8259 = (i8259_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
 
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
 			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -117,17 +117,17 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case IRC_ENABLE_INTERRUPT:
-			async_answer_0(callid, pic_enable_irq(i8259,
+			async_answer_0(chandle, pic_enable_irq(i8259,
 			    IPC_GET_ARG1(call)));
 			break;
 		case IRC_DISABLE_INTERRUPT:
 			/* XXX TODO */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		case IRC_CLEAR_INTERRUPT:
 			/* Noop */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/drv/intctl/icp-ic/icp-ic.c
===================================================================
--- uspace/drv/intctl/icp-ic/icp-ic.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/intctl/icp-ic/icp-ic.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -69,7 +69,7 @@
  * @param arg	Local argument.
  */
-static void icpic_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void icpic_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	icpic_t *icpic;
@@ -78,14 +78,14 @@
 	 * Answer the first IPC_M_CONNECT_ME_TO call.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	icpic = (icpic_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
 
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
 			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -93,17 +93,17 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case IRC_ENABLE_INTERRUPT:
-			async_answer_0(callid,
+			async_answer_0(chandle,
 			    icpic_enable_irq(icpic, IPC_GET_ARG1(call)));
 			break;
 		case IRC_DISABLE_INTERRUPT:
 			/* XXX TODO */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		case IRC_CLEAR_INTERRUPT:
 			/* Noop */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/drv/intctl/obio/obio.c
===================================================================
--- uspace/drv/intctl/obio/obio.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/drv/intctl/obio/obio.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -73,7 +73,7 @@
  * @param arg		Local argument.
  */
-static void obio_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void obio_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	obio_t *obio;
@@ -82,5 +82,5 @@
 	 * Answer the first IPC_M_CONNECT_ME_TO call.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	obio = (obio_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
@@ -89,5 +89,5 @@
 		int inr;
 
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		switch (IPC_GET_IMETHOD(call)) {
 		case IRC_ENABLE_INTERRUPT:
@@ -95,17 +95,17 @@
 			pio_set_64(&obio->regs[OBIO_IMR(inr & INO_MASK)],
 			    1UL << 31, 0);
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		case IRC_DISABLE_INTERRUPT:
 			/* XXX TODO */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		case IRC_CLEAR_INTERRUPT:
 			inr = IPC_GET_ARG1(call);
 			pio_write_64(&obio->regs[OBIO_CIR(inr & INO_MASK)], 0);
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/lib/c/generic/bd.c
===================================================================
--- uspace/lib/c/generic/bd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/bd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -46,5 +46,5 @@
 #include <offset.h>
 
-static void bd_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void bd_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 errno_t bd_open(async_sess_t *sess, bd_t **rbd)
@@ -196,5 +196,5 @@
 }
 
-static void bd_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void bd_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	bd_t *bd = (bd_t *)arg;
@@ -204,5 +204,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -213,5 +213,5 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/bd_srv.c
===================================================================
--- uspace/lib/c/generic/bd_srv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/bd_srv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -43,5 +43,5 @@
 #include <bd_srv.h>
 
-static void bd_read_blocks_srv(bd_srv_t *srv, cap_call_handle_t callid,
+static void bd_read_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -51,11 +51,11 @@
 	size_t size;
 	errno_t rc;
-	cap_call_handle_t rcallid;
+	cap_call_handle_t rcall_handle;
 
 	ba = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
 	cnt = IPC_GET_ARG3(*call);
 
-	if (!async_data_read_receive(&rcallid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&rcall_handle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -63,12 +63,12 @@
 	buf = malloc(size);
 	if (buf == NULL) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	if (srv->srvs->ops->read_blocks == NULL) {
-		async_answer_0(rcallid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(rcall_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		free(buf);
 		return;
@@ -77,17 +77,17 @@
 	rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
 	if (rc != EOK) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
-		free(buf);
-		return;
-	}
-
-	async_data_read_finalize(rcallid, buf, size);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		free(buf);
+		return;
+	}
+
+	async_data_read_finalize(rcall_handle, buf, size);
 
 	free(buf);
-	async_answer_0(callid, EOK);
-}
-
-static void bd_read_toc_srv(bd_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void bd_read_toc_srv(bd_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -96,10 +96,10 @@
 	size_t size;
 	errno_t rc;
-	cap_call_handle_t rcallid;
+	cap_call_handle_t rcall_handle;
 
 	session = IPC_GET_ARG1(*call);
 
-	if (!async_data_read_receive(&rcallid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&rcall_handle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -107,12 +107,12 @@
 	buf = malloc(size);
 	if (buf == NULL) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	if (srv->srvs->ops->read_toc == NULL) {
-		async_answer_0(rcallid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(rcall_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		free(buf);
 		return;
@@ -121,17 +121,17 @@
 	rc = srv->srvs->ops->read_toc(srv, session, buf, size);
 	if (rc != EOK) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
-		free(buf);
-		return;
-	}
-
-	async_data_read_finalize(rcallid, buf, size);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		free(buf);
+		return;
+	}
+
+	async_data_read_finalize(rcall_handle, buf, size);
 
 	free(buf);
-	async_answer_0(callid, EOK);
-}
-
-static void bd_sync_cache_srv(bd_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void bd_sync_cache_srv(bd_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -144,13 +144,13 @@
 
 	if (srv->srvs->ops->sync_cache == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->sync_cache(srv, ba, cnt);
-	async_answer_0(callid, rc);
-}
-
-static void bd_write_blocks_srv(bd_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void bd_write_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -166,10 +166,10 @@
 	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
 	if (srv->srvs->ops->write_blocks == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -177,8 +177,8 @@
 	rc = srv->srvs->ops->write_blocks(srv, ba, cnt, data, size);
 	free(data);
-	async_answer_0(callid, rc);
-}
-
-static void bd_get_block_size_srv(bd_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void bd_get_block_size_srv(bd_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -187,13 +187,13 @@
 
 	if (srv->srvs->ops->get_block_size == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_block_size(srv, &block_size);
-	async_answer_1(callid, rc, block_size);
-}
-
-static void bd_get_num_blocks_srv(bd_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, rc, block_size);
+}
+
+static void bd_get_num_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -202,10 +202,10 @@
 
 	if (srv->srvs->ops->get_num_blocks == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_num_blocks(srv, &num_blocks);
-	async_answer_2(callid, rc, LOWER32(num_blocks), UPPER32(num_blocks));
+	async_answer_2(chandle, rc, LOWER32(num_blocks), UPPER32(num_blocks));
 }
 
@@ -228,5 +228,5 @@
 }
 
-errno_t bd_conn(cap_call_handle_t iid, ipc_call_t *icall, bd_srvs_t *srvs)
+errno_t bd_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, bd_srvs_t *srvs)
 {
 	bd_srv_t *srv;
@@ -234,5 +234,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	srv = bd_srv_create(srvs);
@@ -252,10 +252,10 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -263,23 +263,23 @@
 		switch (method) {
 		case BD_READ_BLOCKS:
-			bd_read_blocks_srv(srv, callid, &call);
+			bd_read_blocks_srv(srv, chandle, &call);
 			break;
 		case BD_READ_TOC:
-			bd_read_toc_srv(srv, callid, &call);
+			bd_read_toc_srv(srv, chandle, &call);
 			break;
 		case BD_SYNC_CACHE:
-			bd_sync_cache_srv(srv, callid, &call);
+			bd_sync_cache_srv(srv, chandle, &call);
 			break;
 		case BD_WRITE_BLOCKS:
-			bd_write_blocks_srv(srv, callid, &call);
+			bd_write_blocks_srv(srv, chandle, &call);
 			break;
 		case BD_GET_BLOCK_SIZE:
-			bd_get_block_size_srv(srv, callid, &call);
+			bd_get_block_size_srv(srv, chandle, &call);
 			break;
 		case BD_GET_NUM_BLOCKS:
-			bd_get_num_blocks_srv(srv, callid, &call);
+			bd_get_num_blocks_srv(srv, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/lib/c/generic/inet.c
===================================================================
--- uspace/lib/c/generic/inet.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/inet.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -36,5 +36,5 @@
 #include <stdlib.h>
 
-static void inet_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void inet_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 static async_sess_t *inet_sess = NULL;
@@ -176,5 +176,5 @@
 }
 
-static void inet_ev_recv(cap_call_handle_t iid, ipc_call_t *icall)
+static void inet_ev_recv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	inet_dgram_t dgram;
@@ -183,41 +183,41 @@
 	dgram.iplink = IPC_GET_ARG2(*icall);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_data_write_finalize(chandle, &dgram.src, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &dgram.dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &dgram.dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -225,5 +225,5 @@
 	rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -231,12 +231,12 @@
 	rc = inet_ev_ops->recv(&dgram);
 	free(dgram.data);
-	async_answer_0(iid, rc);
-}
-
-static void inet_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(icall_handle, rc);
+}
+
+static void inet_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -247,8 +247,8 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case INET_EV_RECV:
-			inet_ev_recv(callid, &call);
+			inet_ev_recv(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/inet/tcp.c
===================================================================
--- uspace/lib/c/generic/inet/tcp.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/inet/tcp.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -637,5 +637,5 @@
  * @param icall Call data
  */
-static void tcp_ev_connected(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
+static void tcp_ev_connected(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	tcp_conn_t *conn;
@@ -647,5 +647,5 @@
 	rc = tcp_conn_get(tcp, conn_id, &conn);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -656,5 +656,5 @@
 	fibril_mutex_unlock(&conn->lock);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -665,5 +665,5 @@
  * @param icall Call data
  */
-static void tcp_ev_conn_failed(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
+static void tcp_ev_conn_failed(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	tcp_conn_t *conn;
@@ -675,5 +675,5 @@
 	rc = tcp_conn_get(tcp, conn_id, &conn);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -684,5 +684,5 @@
 	fibril_mutex_unlock(&conn->lock);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -693,5 +693,5 @@
  * @param icall Call data
  */
-static void tcp_ev_conn_reset(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
+static void tcp_ev_conn_reset(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	tcp_conn_t *conn;
@@ -703,5 +703,5 @@
 	rc = tcp_conn_get(tcp, conn_id, &conn);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -712,5 +712,5 @@
 	fibril_mutex_unlock(&conn->lock);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -721,5 +721,5 @@
  * @param icall Call data
  */
-static void tcp_ev_data(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
+static void tcp_ev_data(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	tcp_conn_t *conn;
@@ -731,5 +731,5 @@
 	rc = tcp_conn_get(tcp, conn_id, &conn);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -741,5 +741,5 @@
 		conn->cb->data_avail(conn);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -750,7 +750,7 @@
  * @param icall Call data
  */
-static void tcp_ev_urg_data(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	async_answer_0(iid, ENOTSUP);
+static void tcp_ev_urg_data(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	async_answer_0(icall_handle, ENOTSUP);
 }
 
@@ -761,5 +761,5 @@
  * @param icall Call data
  */
-static void tcp_ev_new_conn(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
+static void tcp_ev_new_conn(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	tcp_listener_t *lst;
@@ -776,5 +776,5 @@
 	rc = tcp_listener_get(tcp, lst_id, &lst);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -782,5 +782,5 @@
 	rc = tcp_conn_new(tcp, conn_id, lst->cb, lst->cb_arg, &conn);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -789,5 +789,5 @@
 		cinfo = calloc(1, sizeof(tcp_in_conn_t));
 		if (cinfo == NULL) {
-			async_answer_0(iid, ENOMEM);
+			async_answer_0(icall_handle, ENOMEM);
 			return;
 		}
@@ -798,5 +798,5 @@
 		fid = fibril_create(tcp_conn_fibril, cinfo);
 		if (fid == 0) {
-			async_answer_0(iid, ENOMEM);
+			async_answer_0(icall_handle, ENOMEM);
 		}
 
@@ -804,5 +804,5 @@
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -813,13 +813,13 @@
  * @param arg Argument, TCP client
  */
-static void tcp_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void tcp_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	tcp_t *tcp = (tcp_t *)arg;
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -830,23 +830,23 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case TCP_EV_CONNECTED:
-			tcp_ev_connected(tcp, callid, &call);
+			tcp_ev_connected(tcp, chandle, &call);
 			break;
 		case TCP_EV_CONN_FAILED:
-			tcp_ev_conn_failed(tcp, callid, &call);
+			tcp_ev_conn_failed(tcp, chandle, &call);
 			break;
 		case TCP_EV_CONN_RESET:
-			tcp_ev_conn_reset(tcp, callid, &call);
+			tcp_ev_conn_reset(tcp, chandle, &call);
 			break;
 		case TCP_EV_DATA:
-			tcp_ev_data(tcp, callid, &call);
+			tcp_ev_data(tcp, chandle, &call);
 			break;
 		case TCP_EV_URG_DATA:
-			tcp_ev_urg_data(tcp, callid, &call);
+			tcp_ev_urg_data(tcp, chandle, &call);
 			break;
 		case TCP_EV_NEW_CONN:
-			tcp_ev_new_conn(tcp, callid, &call);
+			tcp_ev_new_conn(tcp, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
Index: uspace/lib/c/generic/inet/udp.c
===================================================================
--- uspace/lib/c/generic/inet/udp.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/inet/udp.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -455,5 +455,5 @@
  * @param icall IPC message
  */
-static void udp_ev_data(udp_t *udp, cap_call_handle_t iid, ipc_call_t *icall)
+static void udp_ev_data(udp_t *udp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	udp_rmsg_t rmsg;
@@ -481,5 +481,5 @@
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -490,13 +490,13 @@
  * @param arg Argument, UDP client
  */
-static void udp_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void udp_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	udp_t *udp = (udp_t *)arg;
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -507,8 +507,8 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case UDP_EV_DATA:
-			udp_ev_data(udp, callid, &call);
+			udp_ev_data(udp, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
Index: uspace/lib/c/generic/inetping.c
===================================================================
--- uspace/lib/c/generic/inetping.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/inetping.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -150,5 +150,5 @@
 }
 
-static void inetping_ev_recv(cap_call_handle_t iid, ipc_call_t *icall)
+static void inetping_ev_recv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	inetping_sdu_t sdu;
@@ -156,41 +156,41 @@
 	sdu.seq_no = IPC_GET_ARG1(*icall);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(sdu.src)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_data_write_finalize(callid, &sdu.src, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_data_write_finalize(chandle, &sdu.src, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(sdu.dest)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &sdu.dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &sdu.dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -198,5 +198,5 @@
 	rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -204,12 +204,12 @@
 	rc = inetping_ev_ops->recv(&sdu);
 	free(sdu.data);
-	async_answer_0(iid, rc);
-}
-
-static void inetping_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(icall_handle, rc);
+}
+
+static void inetping_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -220,8 +220,8 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case INETPING_EV_RECV:
-			inetping_ev_recv(callid, &call);
+			inetping_ev_recv(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/io/chardev_srv.c
===================================================================
--- uspace/lib/c/generic/io/chardev_srv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/io/chardev_srv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -43,5 +43,5 @@
 static chardev_srv_t *chardev_srv_create(chardev_srvs_t *);
 
-static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t callid,
+static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -50,8 +50,8 @@
 	size_t nread;
 	errno_t rc;
-	cap_call_handle_t rcallid;
+	cap_call_handle_t rcall_handle;
 
-	if (!async_data_read_receive(&rcallid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&rcall_handle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -59,12 +59,12 @@
 	buf = malloc(size);
 	if (buf == NULL) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	if (srv->srvs->ops->read == NULL) {
-		async_answer_0(rcallid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(rcall_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		free(buf);
 		return;
@@ -73,17 +73,17 @@
 	rc = srv->srvs->ops->read(srv, buf, size, &nread);
 	if (rc != EOK && nread == 0) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		free(buf);
 		return;
 	}
 
-	async_data_read_finalize(rcallid, buf, nread);
+	async_data_read_finalize(rcall_handle, buf, nread);
 
 	free(buf);
-	async_answer_2(callid, EOK, (sysarg_t) rc, nread);
+	async_answer_2(chandle, EOK, (sysarg_t) rc, nread);
 }
 
-static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t callid,
+static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -95,10 +95,10 @@
 	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
 	if (srv->srvs->ops->write == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -107,9 +107,9 @@
 	free(data);
 	if (rc != EOK && nwr == 0) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
-	async_answer_2(callid, EOK, (sysarg_t) rc, nwr);
+	async_answer_2(chandle, EOK, (sysarg_t) rc, nwr);
 }
 
@@ -132,5 +132,5 @@
 }
 
-errno_t chardev_conn(cap_call_handle_t iid, ipc_call_t *icall, chardev_srvs_t *srvs)
+errno_t chardev_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, chardev_srvs_t *srvs)
 {
 	chardev_srv_t *srv;
@@ -138,5 +138,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	srv = chardev_srv_create(srvs);
@@ -152,10 +152,10 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -163,14 +163,14 @@
 		switch (method) {
 		case CHARDEV_READ:
-			chardev_read_srv(srv, callid, &call);
+			chardev_read_srv(srv, chandle, &call);
 			break;
 		case CHARDEV_WRITE:
-			chardev_write_srv(srv, callid, &call);
+			chardev_write_srv(srv, chandle, &call);
 			break;
 		default:
 			if (srv->srvs->ops->def_handler != NULL)
-				srv->srvs->ops->def_handler(srv, callid, &call);
+				srv->srvs->ops->def_handler(srv, chandle, &call);
 			else
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/io/con_srv.c
===================================================================
--- uspace/lib/c/generic/io/con_srv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/io/con_srv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -66,5 +66,5 @@
 }
 
-static void con_read_srv(con_srv_t *srv, cap_call_handle_t callid,
+static void con_read_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -72,8 +72,8 @@
 	size_t size;
 	errno_t rc;
-	cap_call_handle_t rcallid;
-
-	if (!async_data_read_receive(&rcallid, &size)) {
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t rcall_handle;
+
+	if (!async_data_read_receive(&rcall_handle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -81,12 +81,12 @@
 	buf = malloc(size);
 	if (buf == NULL) {
-		async_answer_0(rcallid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(rcall_handle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	if (srv->srvs->ops->read == NULL) {
-		async_answer_0(rcallid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(rcall_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		free(buf);
 		return;
@@ -96,17 +96,17 @@
 	rc = srv->srvs->ops->read(srv, buf, size, &nread);
 	if (rc != EOK) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		free(buf);
 		return;
 	}
 
-	async_data_read_finalize(rcallid, buf, nread);
+	async_data_read_finalize(rcall_handle, buf, nread);
 	free(buf);
 
-	async_answer_1(callid, EOK, nread);
-}
-
-static void con_write_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, EOK, nread);
+}
+
+static void con_write_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -117,10 +117,10 @@
 	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
 	if (srv->srvs->ops->write == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -130,32 +130,32 @@
 	free(data);
 
-	async_answer_1(callid, rc, nwritten);
-}
-
-static void con_sync_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, rc, nwritten);
+}
+
+static void con_sync_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	if (srv->srvs->ops->sync == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->sync(srv);
-	async_answer_0(callid, EOK);
-}
-
-static void con_clear_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_clear_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	if (srv->srvs->ops->clear == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->clear(srv);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -167,13 +167,13 @@
 
 	if (srv->srvs->ops->set_pos == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_pos(srv, col, row);
-	async_answer_0(callid, EOK);
-}
-
-static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -183,13 +183,13 @@
 
 	if (srv->srvs->ops->get_pos == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_pos(srv, &col, &row);
-	async_answer_2(callid, rc, col, row);
-}
-
-static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_2(chandle, rc, col, row);
+}
+
+static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -199,13 +199,13 @@
 
 	if (srv->srvs->ops->get_size == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_size(srv, &cols, &rows);
-	async_answer_2(callid, rc, cols, rows);
-}
-
-static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_2(chandle, rc, cols, rows);
+}
+
+static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -214,13 +214,13 @@
 
 	if (srv->srvs->ops->get_color_cap == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	rc = srv->srvs->ops->get_color_cap(srv, &ccap);
-	async_answer_1(callid, rc, (sysarg_t)ccap);
-}
-
-static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_1(chandle, rc, (sysarg_t)ccap);
+}
+
+static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -230,13 +230,13 @@
 
 	if (srv->srvs->ops->set_style == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_style(srv, style);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -250,13 +250,13 @@
 
 	if (srv->srvs->ops->set_color == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_color(srv, bgcolor, fgcolor, flags);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -268,13 +268,13 @@
 
 	if (srv->srvs->ops->set_rgb_color == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_rgb_color(srv, bgcolor, fgcolor);
-	async_answer_0(callid, EOK);
-}
-
-static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -284,13 +284,13 @@
 
 	if (srv->srvs->ops->set_cursor_visibility == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	srv->srvs->ops->set_cursor_visibility(srv, show);
-	async_answer_0(callid, EOK);
-}
-
-static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -300,5 +300,5 @@
 
 	if (srv->srvs->ops->get_event == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -306,5 +306,5 @@
 	rc = srv->srvs->ops->get_event(srv, &event);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -312,9 +312,9 @@
 	rc = console_ev_encode(&event, &result);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		return;
-	}
-
-	async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
+		async_answer_0(chandle, rc);
+		return;
+	}
+
+	async_answer_5(chandle, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
 	    IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
 }
@@ -340,5 +340,5 @@
 }
 
-errno_t con_conn(cap_call_handle_t iid, ipc_call_t *icall, con_srvs_t *srvs)
+errno_t con_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, con_srvs_t *srvs)
 {
 	con_srv_t *srv;
@@ -346,5 +346,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	srv = con_srv_create(srvs);
@@ -366,19 +366,19 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = 0;
-
-		while (callid == 0) {
+		cap_call_handle_t chandle = 0;
+
+		while (chandle == 0) {
 			/* XXX Need to be able to abort immediately */
-			callid = async_get_call_timeout(&call,
+			chandle = async_get_call_timeout(&call,
 			    srvs->abort_timeout);
 
 			if (srv->srvs->aborted) {
-				if (callid != 0)
-					async_answer_0(callid, EINTR);
+				if (chandle != 0)
+					async_answer_0(chandle, EINTR);
 				break;
 			}
 		}
 
-		if (callid == 0)
+		if (chandle == 0)
 			break;
 
@@ -387,5 +387,5 @@
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -393,44 +393,44 @@
 		switch (method) {
 		case VFS_OUT_READ:
-			con_read_srv(srv, callid, &call);
+			con_read_srv(srv, chandle, &call);
 			break;
 		case VFS_OUT_WRITE:
-			con_write_srv(srv, callid, &call);
+			con_write_srv(srv, chandle, &call);
 			break;
 		case VFS_OUT_SYNC:
-			con_sync_srv(srv, callid, &call);
+			con_sync_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_CLEAR:
-			con_clear_srv(srv, callid, &call);
+			con_clear_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_POS:
-			con_set_pos_srv(srv, callid, &call);
+			con_set_pos_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_POS:
-			con_get_pos_srv(srv, callid, &call);
+			con_get_pos_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_SIZE:
-			con_get_size_srv(srv, callid, &call);
+			con_get_size_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_COLOR_CAP:
-			con_get_color_cap_srv(srv, callid, &call);
+			con_get_color_cap_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_STYLE:
-			con_set_style_srv(srv, callid, &call);
+			con_set_style_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_COLOR:
-			con_set_color_srv(srv, callid, &call);
+			con_set_color_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_RGB_COLOR:
-			con_set_rgb_color_srv(srv, callid, &call);
+			con_set_rgb_color_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_SET_CURSOR_VISIBILITY:
-			con_set_cursor_visibility_srv(srv, callid, &call);
+			con_set_cursor_visibility_srv(srv, chandle, &call);
 			break;
 		case CONSOLE_GET_EVENT:
-			con_get_event_srv(srv, callid, &call);
+			con_get_event_srv(srv, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/io/input.c
===================================================================
--- uspace/lib/c/generic/io/input.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/io/input.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -43,5 +43,5 @@
 #include <stdlib.h>
 
-static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 errno_t input_open(async_sess_t *sess, input_ev_ops_t *ev_ops,
@@ -92,19 +92,19 @@
 }
 
-static void input_ev_active(input_t *input, cap_call_handle_t callid,
+static void input_ev_active(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	errno_t rc = input->ev_ops->active(input);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_deactive(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_deactive(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	errno_t rc = input->ev_ops->deactive(input);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_key(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_key(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -121,8 +121,8 @@
 
 	rc = input->ev_ops->key(input, type, key, mods, c);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_move(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_move(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -135,8 +135,8 @@
 
 	rc = input->ev_ops->move(input, dx, dy);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_abs_move(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_abs_move(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -153,8 +153,8 @@
 
 	rc = input->ev_ops->abs_move(input, x, y, max_x, max_y);
-	async_answer_0(callid, rc);
-}
-
-static void input_ev_button(input_t *input, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void input_ev_button(input_t *input, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -167,8 +167,8 @@
 
 	rc = input->ev_ops->button(input, bnum, press);
-	async_answer_0(callid, rc);
-}
-
-static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(chandle, rc);
+}
+
+static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	input_t *input = (input_t *)arg;
@@ -176,5 +176,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -185,23 +185,23 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case INPUT_EVENT_ACTIVE:
-			input_ev_active(input, callid, &call);
+			input_ev_active(input, chandle, &call);
 			break;
 		case INPUT_EVENT_DEACTIVE:
-			input_ev_deactive(input, callid, &call);
+			input_ev_deactive(input, chandle, &call);
 			break;
 		case INPUT_EVENT_KEY:
-			input_ev_key(input, callid, &call);
+			input_ev_key(input, chandle, &call);
 			break;
 		case INPUT_EVENT_MOVE:
-			input_ev_move(input, callid, &call);
+			input_ev_move(input, chandle, &call);
 			break;
 		case INPUT_EVENT_ABS_MOVE:
-			input_ev_abs_move(input, callid, &call);
+			input_ev_abs_move(input, chandle, &call);
 			break;
 		case INPUT_EVENT_BUTTON:
-			input_ev_button(input, callid, &call);
+			input_ev_button(input, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/iplink.c
===================================================================
--- uspace/lib/c/generic/iplink.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/iplink.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -45,5 +45,5 @@
 #include <stdlib.h>
 
-static void iplink_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void iplink_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 errno_t iplink_open(async_sess_t *sess, iplink_ev_ops_t *ev_ops, void *arg,
@@ -245,5 +245,5 @@
 }
 
-static void iplink_ev_recv(iplink_t *iplink, cap_call_handle_t iid,
+static void iplink_ev_recv(iplink_t *iplink, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -255,5 +255,5 @@
 	    &sdu.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -261,8 +261,8 @@
 	rc = iplink->ev_ops->recv(iplink, &sdu, ver);
 	free(sdu.data);
-	async_answer_0(iid, rc);
-}
-
-static void iplink_ev_change_addr(iplink_t *iplink, cap_call_handle_t iid,
+	async_answer_0(icall_handle, rc);
+}
+
+static void iplink_ev_change_addr(iplink_t *iplink, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -273,5 +273,5 @@
 	    sizeof(addr48_t), sizeof(addr48_t), 0, &size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -279,8 +279,8 @@
 	rc = iplink->ev_ops->change_addr(iplink, *addr);
 	free(addr);
-	async_answer_0(iid, EOK);
-}
-
-static void iplink_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void iplink_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	iplink_t *iplink = (iplink_t *) arg;
@@ -288,5 +288,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -297,11 +297,11 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case IPLINK_EV_RECV:
-			iplink_ev_recv(iplink, callid, &call);
+			iplink_ev_recv(iplink, chandle, &call);
 			break;
 		case IPLINK_EV_CHANGE_ADDR:
-			iplink_ev_change_addr(iplink, callid, &call);
+			iplink_ev_change_addr(iplink, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/iplink_srv.c
===================================================================
--- uspace/lib/c/generic/iplink_srv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/iplink_srv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -42,13 +42,13 @@
 #include <inet/iplink_srv.h>
 
-static void iplink_get_mtu_srv(iplink_srv_t *srv, cap_call_handle_t callid,
+static void iplink_get_mtu_srv(iplink_srv_t *srv, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	size_t mtu;
 	errno_t rc = srv->ops->get_mtu(srv, &mtu);
-	async_answer_1(callid, rc, mtu);
-}
-
-static void iplink_get_mac48_srv(iplink_srv_t *srv, cap_call_handle_t iid,
+	async_answer_1(chandle, rc, mtu);
+}
+
+static void iplink_get_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -56,30 +56,30 @@
 	errno_t rc = srv->ops->get_mac48(srv, &mac);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(addr48_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &mac, size);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &mac, size);
 	if (rc != EOK)
-		async_answer_0(callid, rc);
-
-	async_answer_0(iid, rc);
-}
-
-static void iplink_set_mac48_srv(iplink_srv_t *srv, cap_call_handle_t iid,
+		async_answer_0(chandle, rc);
+
+	async_answer_0(icall_handle, rc);
+}
+
+static void iplink_set_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -87,81 +87,81 @@
 	size_t size;
 	addr48_t mac;
-	cap_call_handle_t callid;
-
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	cap_call_handle_t chandle;
+
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 	}
 
 	rc = srv->ops->set_mac48(srv, &mac);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &mac, sizeof(addr48_t));
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &mac, sizeof(addr48_t));
 	if (rc != EOK)
-		async_answer_0(callid, rc);
-
-	async_answer_0(iid, rc);
-}
-
-static void iplink_addr_add_srv(iplink_srv_t *srv, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, rc);
+
+	async_answer_0(icall_handle, rc);
+}
+
+static void iplink_addr_add_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
+    ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	inet_addr_t addr;
-	errno_t rc = async_data_write_finalize(callid, &addr, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+	errno_t rc = async_data_write_finalize(chandle, &addr, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 	}
 
 	rc = srv->ops->addr_add(srv, &addr);
-	async_answer_0(iid, rc);
-}
-
-static void iplink_addr_remove_srv(iplink_srv_t *srv, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	async_answer_0(icall_handle, rc);
+}
+
+static void iplink_addr_remove_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
+    ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	inet_addr_t addr;
-	errno_t rc = async_data_write_finalize(callid, &addr, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+	errno_t rc = async_data_write_finalize(chandle, &addr, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 	}
 
 	rc = srv->ops->addr_remove(srv, &addr);
-	async_answer_0(iid, rc);
-}
-
-static void iplink_send_srv(iplink_srv_t *srv, cap_call_handle_t iid,
+	async_answer_0(icall_handle, rc);
+}
+
+static void iplink_send_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -174,5 +174,5 @@
 	    &sdu.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -180,30 +180,30 @@
 	rc = srv->ops->send(srv, &sdu);
 	free(sdu.data);
-	async_answer_0(iid, rc);
-}
-
-static void iplink_send6_srv(iplink_srv_t *srv, cap_call_handle_t iid,
+	async_answer_0(icall_handle, rc);
+}
+
+static void iplink_send6_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
 	iplink_sdu6_t sdu;
 
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(addr48_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_data_write_finalize(callid, &sdu.dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_data_write_finalize(chandle, &sdu.dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 	}
 
@@ -211,5 +211,5 @@
 	    &sdu.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -217,5 +217,5 @@
 	rc = srv->ops->send6(srv, &sdu);
 	free(sdu.data);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -229,5 +229,5 @@
 }
 
-errno_t iplink_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+errno_t iplink_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	iplink_srv_t *srv = (iplink_srv_t *) arg;
@@ -237,5 +237,5 @@
 	if (srv->connected) {
 		fibril_mutex_unlock(&srv->lock);
-		async_answer_0(iid, EBUSY);
+		async_answer_0(icall_handle, EBUSY);
 		return EBUSY;
 	}
@@ -245,5 +245,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
@@ -259,5 +259,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
@@ -267,5 +267,5 @@
 			srv->connected = false;
 			fibril_mutex_unlock(&srv->lock);
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -273,26 +273,26 @@
 		switch (method) {
 		case IPLINK_GET_MTU:
-			iplink_get_mtu_srv(srv, callid, &call);
+			iplink_get_mtu_srv(srv, chandle, &call);
 			break;
 		case IPLINK_GET_MAC48:
-			iplink_get_mac48_srv(srv, callid, &call);
+			iplink_get_mac48_srv(srv, chandle, &call);
 			break;
 		case IPLINK_SET_MAC48:
-			iplink_set_mac48_srv(srv, callid, &call);
+			iplink_set_mac48_srv(srv, chandle, &call);
 			break;
 		case IPLINK_SEND:
-			iplink_send_srv(srv, callid, &call);
+			iplink_send_srv(srv, chandle, &call);
 			break;
 		case IPLINK_SEND6:
-			iplink_send6_srv(srv, callid, &call);
+			iplink_send6_srv(srv, chandle, &call);
 			break;
 		case IPLINK_ADDR_ADD:
-			iplink_addr_add_srv(srv, callid, &call);
+			iplink_addr_add_srv(srv, chandle, &call);
 			break;
 		case IPLINK_ADDR_REMOVE:
-			iplink_addr_remove_srv(srv, callid, &call);
+			iplink_addr_remove_srv(srv, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/lib/c/generic/loc.c
===================================================================
--- uspace/lib/c/generic/loc.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/loc.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -55,9 +55,9 @@
 static async_sess_t *loc_consumer_sess = NULL;
 
-static void loc_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void loc_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -72,5 +72,5 @@
 			fibril_mutex_unlock(&loc_callback_mutex);
 
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 
 			if (cb_fun != NULL)
@@ -79,5 +79,5 @@
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -802,7 +802,7 @@
 errno_t vfs_receive_handle(bool high, int *handle)
 {
-	cap_call_handle_t callid;
-	if (!async_state_change_receive(&callid, NULL, NULL, NULL)) {
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t chandle;
+	if (!async_state_change_receive(&chandle, NULL, NULL, NULL)) {
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -810,5 +810,5 @@
 	async_exch_t *vfs_exch = vfs_exchange_begin();
 
-	async_state_change_finalize(callid, vfs_exch);
+	async_state_change_finalize(chandle, vfs_exch);
 
 	sysarg_t ret;
Index: uspace/lib/drv/generic/driver.c
===================================================================
--- uspace/lib/drv/generic/driver.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/driver.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -118,5 +118,5 @@
 }
 
-static void driver_dev_add(cap_call_handle_t iid, ipc_call_t *icall)
+static void driver_dev_add(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
@@ -126,5 +126,5 @@
 	errno_t rc = async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -134,5 +134,5 @@
 	if (stopping) {
 		fibril_rwlock_read_unlock(&stopping_lock);
-		async_answer_0(iid, EIO);
+		async_answer_0(icall_handle, EIO);
 		return;
 	}
@@ -142,5 +142,5 @@
 		fibril_rwlock_read_unlock(&stopping_lock);
 		free(dev_name);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -162,5 +162,5 @@
 		fibril_rwlock_read_unlock(&stopping_lock);
 		dev_del_ref(dev);
-		async_answer_0(iid, res);
+		async_answer_0(icall_handle, res);
 		return;
 	}
@@ -171,8 +171,8 @@
 	fibril_rwlock_read_unlock(&stopping_lock);
 
-	async_answer_0(iid, res);
-}
-
-static void driver_dev_remove(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, res);
+}
+
+static void driver_dev_remove(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t devh = IPC_GET_ARG1(*icall);
@@ -185,5 +185,5 @@
 
 	if (dev == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -204,8 +204,8 @@
 
 	dev_del_ref(dev);
-	async_answer_0(iid, rc);
-}
-
-static void driver_dev_gone(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void driver_dev_gone(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t devh = IPC_GET_ARG1(*icall);
@@ -218,5 +218,5 @@
 
 	if (dev == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -237,8 +237,8 @@
 
 	dev_del_ref(dev);
-	async_answer_0(iid, rc);
-}
-
-static void driver_fun_online(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void driver_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t funh = IPC_GET_ARG1(*icall);
@@ -258,5 +258,5 @@
 
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -272,8 +272,8 @@
 	fun_del_ref(fun);
 
-	async_answer_0(iid, rc);
-}
-
-static void driver_fun_offline(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void driver_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t funh = IPC_GET_ARG1(*icall);
@@ -293,5 +293,5 @@
 
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -305,8 +305,8 @@
 		rc = ENOTSUP;
 
-	async_answer_0(iid, rc);
-}
-
-static void driver_stop(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void driver_stop(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	/* Prevent new devices from being added */
@@ -321,5 +321,5 @@
 		stopping = false;
 		fibril_rwlock_write_unlock(&stopping_lock);
-		async_answer_0(iid, EBUSY);
+		async_answer_0(icall_handle, EBUSY);
 		return;
 	}
@@ -333,17 +333,17 @@
 
 	/* Reply with success and terminate */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 	exit(0);
 }
 
-static void driver_connection_devman(cap_call_handle_t iid, ipc_call_t *icall,
+static void driver_connection_devman(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
 	/* Accept connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -352,23 +352,23 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case DRIVER_DEV_ADD:
-			driver_dev_add(callid, &call);
+			driver_dev_add(chandle, &call);
 			break;
 		case DRIVER_DEV_REMOVE:
-			driver_dev_remove(callid, &call);
+			driver_dev_remove(chandle, &call);
 			break;
 		case DRIVER_DEV_GONE:
-			driver_dev_gone(callid, &call);
+			driver_dev_gone(chandle, &call);
 			break;
 		case DRIVER_FUN_ONLINE:
-			driver_fun_online(callid, &call);
+			driver_fun_online(chandle, &call);
 			break;
 		case DRIVER_FUN_OFFLINE:
-			driver_fun_offline(callid, &call);
+			driver_fun_offline(chandle, &call);
 			break;
 		case DRIVER_STOP:
-			driver_stop(callid, &call);
+			driver_stop(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
@@ -381,5 +381,5 @@
  *
  */
-static void driver_connection_gen(cap_call_handle_t iid, ipc_call_t *icall, bool drv)
+static void driver_connection_gen(cap_call_handle_t icall_handle, ipc_call_t *icall, bool drv)
 {
 	/*
@@ -398,5 +398,5 @@
 		printf("%s: driver_connection_gen error - no function with handle"
 		    " %" PRIun " was found.\n", driver->name, handle);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -404,5 +404,5 @@
 	if (fun->conn_handler != NULL) {
 		/* Driver has a custom connection handler. */
-		(*fun->conn_handler)(iid, icall, (void *)fun);
+		(*fun->conn_handler)(icall_handle, icall, (void *)fun);
 		fun_del_ref(fun);
 		return;
@@ -419,5 +419,5 @@
 		ret = (*fun->ops->open)(fun);
 
-	async_answer_0(iid, ret);
+	async_answer_0(icall_handle, ret);
 	if (ret != EOK) {
 		fun_del_ref(fun);
@@ -426,7 +426,7 @@
 
 	while (true) {
-		cap_call_handle_t callid;
+		cap_call_handle_t chandle;
 		ipc_call_t call;
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
@@ -435,5 +435,5 @@
 			if (fun->ops != NULL && fun->ops->close != NULL)
 				(*fun->ops->close)(fun);
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			fun_del_ref(fun);
 			return;
@@ -448,5 +448,5 @@
 			    function_get_default_handler(fun);
 			if (default_handler != NULL) {
-				(*default_handler)(fun, callid, &call);
+				(*default_handler)(fun, chandle, &call);
 				continue;
 			}
@@ -459,5 +459,5 @@
 			    "invalid interface id %d.",
 			    driver->name, iface_idx);
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			continue;
 		}
@@ -471,5 +471,5 @@
 			printf("Function with handle %" PRIun " has no interface "
 			    "with id %d.\n", handle, iface_idx);
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			continue;
 		}
@@ -490,5 +490,5 @@
 			printf("%s: driver_connection_gen error - "
 			    "invalid interface method.", driver->name);
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			continue;
 		}
@@ -500,18 +500,18 @@
 		 * associated with the function by its driver.
 		 */
-		(*iface_method_ptr)(fun, ops, callid, &call);
-	}
-}
-
-static void driver_connection_driver(cap_call_handle_t iid, ipc_call_t *icall,
+		(*iface_method_ptr)(fun, ops, chandle, &call);
+	}
+}
+
+static void driver_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
-	driver_connection_gen(iid, icall, true);
-}
-
-static void driver_connection_client(cap_call_handle_t iid, ipc_call_t *icall,
+	driver_connection_gen(icall_handle, icall, true);
+}
+
+static void driver_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
-	driver_connection_gen(iid, icall, false);
+	driver_connection_gen(icall_handle, icall, false);
 }
 
Index: uspace/lib/drv/generic/remote_ahci.c
===================================================================
--- uspace/lib/drv/generic/remote_ahci.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_ahci.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -210,10 +210,10 @@
 
 void remote_ahci_get_sata_device_name(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
 	if (ahci_iface->get_sata_device_name == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -224,5 +224,5 @@
 	char* sata_dev_name = malloc(sata_dev_name_length);
 	if (sata_dev_name == NULL) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -232,20 +232,21 @@
 
 	size_t real_size;
-	cap_call_handle_t cid;
-	if ((async_data_read_receive(&cid, &real_size)) &&
+	cap_call_handle_t call_handle;
+	if ((async_data_read_receive(&call_handle, &real_size)) &&
 	    (real_size == sata_dev_name_length))
-		async_data_read_finalize(cid, sata_dev_name, sata_dev_name_length);
+		async_data_read_finalize(call_handle, sata_dev_name,
+		    sata_dev_name_length);
 
 	free(sata_dev_name);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_ahci_get_num_blocks(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
 	if (ahci_iface->get_num_blocks == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -255,16 +256,16 @@
 
 	if (ret != EOK)
-		async_answer_0(callid, ret);
+		async_answer_0(chandle, ret);
 	else
-		async_answer_2(callid, EOK, HI(blocks), LO(blocks));
+		async_answer_2(chandle, EOK, HI(blocks), LO(blocks));
 }
 
 static void remote_ahci_get_block_size(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
 	if (ahci_iface->get_block_size == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -274,16 +275,16 @@
 
 	if (ret != EOK)
-		async_answer_0(callid, ret);
+		async_answer_0(chandle, ret);
 	else
-		async_answer_1(callid, EOK, blocks);
+		async_answer_1(chandle, EOK, blocks);
 }
 
 void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
 	if (ahci_iface->read_blocks == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -292,9 +293,9 @@
 	unsigned int flags;
 
-	cap_call_handle_t cid;
-	async_share_out_receive(&cid, &maxblock_size, &flags);
+	cap_call_handle_t call_handle;
+	async_share_out_receive(&call_handle, &maxblock_size, &flags);
 
 	void *buf;
-	async_share_out_finalize(cid, &buf);
+	async_share_out_finalize(call_handle, &buf);
 
 	const uint64_t blocknum =
@@ -305,8 +306,8 @@
 	const errno_t ret = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
 
-	async_answer_0(callid, ret);
-}
-
-void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t callid,
+	async_answer_0(chandle, ret);
+}
+
+void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -314,5 +315,5 @@
 
 	if (ahci_iface->read_blocks == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -321,9 +322,9 @@
 	unsigned int flags;
 
-	cap_call_handle_t cid;
-	async_share_out_receive(&cid, &maxblock_size, &flags);
+	cap_call_handle_t call_handle;
+	async_share_out_receive(&call_handle, &maxblock_size, &flags);
 
 	void *buf;
-	async_share_out_finalize(cid, &buf);
+	async_share_out_finalize(call_handle, &buf);
 
 	const uint64_t blocknum =
@@ -334,5 +335,5 @@
 	const errno_t ret = ahci_iface->write_blocks(fun, blocknum, cnt, buf);
 
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
Index: uspace/lib/drv/generic/remote_audio_mixer.c
===================================================================
--- uspace/lib/drv/generic/remote_audio_mixer.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_audio_mixer.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -219,10 +219,10 @@
 
 void remote_audio_mixer_get_info(
-    ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	audio_mixer_iface_t *mixer_iface = iface;
 
 	if (!mixer_iface->get_info) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -231,5 +231,5 @@
 	const errno_t ret = mixer_iface->get_info(fun, &name, &items);
 	const size_t name_size = name ? str_size(name) + 1 : 0;
-	async_answer_2(callid, ret, name_size, items);
+	async_answer_2(chandle, ret, name_size, items);
 	/* Send the name. */
 	if (ret == EOK && name_size > 0) {
@@ -249,10 +249,10 @@
 
 void remote_audio_mixer_get_item_info(
-    ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	audio_mixer_iface_t *mixer_iface = iface;
 
 	if (!mixer_iface->get_item_info) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -263,5 +263,5 @@
 	const errno_t ret = mixer_iface->get_item_info(fun, item, &name, &values);
 	const size_t name_size = name ? str_size(name) + 1 : 0;
-	async_answer_2(callid, ret, name_size, values);
+	async_answer_2(chandle, ret, name_size, values);
 	/* Send the name. */
 	if (ret == EOK && name_size > 0) {
@@ -281,10 +281,10 @@
 
 void remote_audio_mixer_set_item_level(
-    ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	audio_mixer_iface_t *mixer_iface = iface;
 
 	if (!mixer_iface->set_item_level) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -292,14 +292,14 @@
 	const unsigned value = DEV_IPC_GET_ARG2(*call);
 	const errno_t ret = mixer_iface->set_item_level(fun, item, value);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 void remote_audio_mixer_get_item_level(
-    ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	audio_mixer_iface_t *mixer_iface = iface;
 
 	if (!mixer_iface->get_item_level) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -308,5 +308,5 @@
 	const errno_t ret =
 	    mixer_iface->get_item_level(fun, item, &current);
-	async_answer_1(callid, ret, current);
+	async_answer_1(chandle, ret, current);
 }
 
Index: uspace/lib/drv/generic/remote_audio_pcm.c
===================================================================
--- uspace/lib/drv/generic/remote_audio_pcm.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_audio_pcm.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -632,10 +632,10 @@
 
 void remote_audio_pcm_get_info_str(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
 
 	if (!pcm_iface->get_info_str) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -643,5 +643,5 @@
 	const errno_t ret = pcm_iface->get_info_str(fun, &name);
 	const size_t name_size = name ? str_size(name) + 1 : 0;
-	async_answer_1(callid, ret, name_size);
+	async_answer_1(chandle, ret, name_size);
 	/* Send the string. */
 	if (ret == EOK && name_size > 0) {
@@ -660,5 +660,6 @@
 }
 
-void remote_audio_pcm_query_caps(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+void remote_audio_pcm_query_caps(ddf_fun_t *fun, void *iface,
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -666,28 +667,29 @@
 	if (pcm_iface->query_cap) {
 		const unsigned value = pcm_iface->query_cap(fun, cap);
-		async_answer_1(callid, EOK, value);
+		async_answer_1(chandle, EOK, value);
 	} else {
-		async_answer_0(callid, ENOTSUP);
-	}
-}
-
-static void remote_audio_pcm_events_register(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, ENOTSUP);
+	}
+}
+
+static void remote_audio_pcm_events_register(ddf_fun_t *fun, void *iface,
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
 	if (!pcm_iface->get_event_session ||
 	    !pcm_iface->set_event_session) {
-		async_answer_0(callid, ENOTSUP);
-		return;
-	}
-
-	async_answer_0(callid, EOK);
+		async_answer_0(chandle, ENOTSUP);
+		return;
+	}
+
+	async_answer_0(chandle, EOK);
 
 	ipc_call_t callback_call;
-	cap_call_handle_t callback_id = async_get_call(&callback_call);
+	cap_call_handle_t callback_handle = async_get_call(&callback_call);
 	async_sess_t *sess =
 	    async_callback_receive_start(EXCHANGE_ATOMIC, &callback_call);
 	if (sess == NULL) {
 		ddf_msg(LVL_DEBUG, "Failed to create event callback");
-		async_answer_0(callback_id, EAGAIN);
+		async_answer_0(callback_handle, EAGAIN);
 		return;
 	}
@@ -696,16 +698,17 @@
 		ddf_msg(LVL_DEBUG, "Failed to set event callback.");
 		async_hangup(sess);
-		async_answer_0(callback_id, ret);
-		return;
-	}
-	async_answer_0(callback_id, EOK);
-}
-
-static void remote_audio_pcm_events_unregister(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(callback_handle, ret);
+		return;
+	}
+	async_answer_0(callback_handle, EOK);
+}
+
+static void remote_audio_pcm_events_unregister(ddf_fun_t *fun, void *iface,
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
 	if (!pcm_iface->get_event_session ||
 	    !pcm_iface->set_event_session) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -715,8 +718,9 @@
 		pcm_iface->set_event_session(fun, NULL);
 	}
-	async_answer_0(callid, EOK);
-}
-
-void remote_audio_pcm_get_buffer_pos(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_0(chandle, EOK);
+}
+
+void remote_audio_pcm_get_buffer_pos(ddf_fun_t *fun, void *iface,
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -724,8 +728,9 @@
 	const errno_t ret = pcm_iface->get_buffer_pos ?
 	    pcm_iface->get_buffer_pos(fun, &pos) : ENOTSUP;
-	async_answer_1(callid, ret, pos);
-}
-
-void remote_audio_pcm_test_format(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_1(chandle, ret, pos);
+}
+
+void remote_audio_pcm_test_format(ddf_fun_t *fun, void *iface,
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -735,9 +740,9 @@
 	const errno_t ret = pcm_iface->test_format ?
 	    pcm_iface->test_format(fun, &channels, &rate, &format) : ENOTSUP;
-	async_answer_3(callid, ret, channels, rate, format);
+	async_answer_3(chandle, ret, channels, rate, format);
 }
 
 void remote_audio_pcm_get_buffer(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -745,5 +750,5 @@
 	if (!pcm_iface->get_buffer ||
 	    !pcm_iface->release_buffer) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -751,5 +756,5 @@
 	size_t size = DEV_IPC_GET_ARG1(*call);
 	errno_t ret = pcm_iface->get_buffer(fun, &buffer, &size);
-	async_answer_1(callid, ret, size);
+	async_answer_1(chandle, ret, size);
 	if (ret != EOK || size == 0)
 		return;
@@ -788,5 +793,5 @@
 
 void remote_audio_pcm_release_buffer(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -794,9 +799,9 @@
 	const errno_t ret = pcm_iface->release_buffer ?
 	    pcm_iface->release_buffer(fun) : ENOTSUP;
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 void remote_audio_pcm_start_playback(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -810,9 +815,9 @@
 	    ? pcm_iface->start_playback(fun, frames, channels, rate, format)
 	    : ENOTSUP;
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 void remote_audio_pcm_stop_playback(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -821,9 +826,9 @@
 	const errno_t ret = pcm_iface->stop_playback ?
 	    pcm_iface->stop_playback(fun, immediate) : ENOTSUP;
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 void remote_audio_pcm_start_capture(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -837,9 +842,9 @@
 	    ? pcm_iface->start_capture(fun, frames, channels, rate, format)
 	    : ENOTSUP;
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 void remote_audio_pcm_stop_capture(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const audio_pcm_iface_t *pcm_iface = iface;
@@ -848,5 +853,5 @@
 	const errno_t ret = pcm_iface->stop_capture ?
 	    pcm_iface->stop_capture(fun, immediate) : ENOTSUP;
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
Index: uspace/lib/drv/generic/remote_battery_dev.c
===================================================================
--- uspace/lib/drv/generic/remote_battery_dev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_battery_dev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -118,5 +118,5 @@
  */
 static void
-remote_battery_status_get(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
+remote_battery_status_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -124,5 +124,5 @@
 
 	if (bops->battery_status_get == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -132,7 +132,7 @@
 
 	if (rc != EOK)
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	else
-		async_answer_1(callid, rc, batt_status);
+		async_answer_1(chandle, rc, batt_status);
 }
 
@@ -144,5 +144,5 @@
  */
 static void
-remote_battery_charge_level_get(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
+remote_battery_charge_level_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -150,5 +150,5 @@
 
 	if (bops->battery_charge_level_get == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -158,7 +158,7 @@
 
 	if (rc != EOK)
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	else
-		async_answer_1(callid, rc, battery_level);
+		async_answer_1(chandle, rc, battery_level);
 }
 
Index: uspace/lib/drv/generic/remote_clock_dev.c
===================================================================
--- uspace/lib/drv/generic/remote_clock_dev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_clock_dev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -69,16 +69,16 @@
  */
 static void
-remote_clock_time_get(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
+remote_clock_time_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops;
-	cap_call_handle_t cid;
+	cap_call_handle_t call_handle;
 	struct tm t;
 	errno_t rc;
 	size_t len;
 
-	if (!async_data_read_receive(&cid, &len)) {
+	if (!async_data_read_receive(&call_handle, &len)) {
 		/* TODO: Handle protocol error */
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -86,6 +86,6 @@
 	if (!clock_dev_ops->time_get) {
 		/* The driver does not provide the time_get() functionality */
-		async_answer_0(cid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(call_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -95,12 +95,12 @@
 	if (rc != EOK) {
 		/* Some error occurred */
-		async_answer_0(cid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(call_handle, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
 
 	/* The operation was successful */
-	async_data_read_finalize(cid, &t, sizeof(struct tm));
-	async_answer_0(callid, rc);
+	async_data_read_finalize(call_handle, &t, sizeof(struct tm));
+	async_answer_0(chandle, rc);
 }
 
@@ -111,15 +111,15 @@
  */
 static void remote_clock_time_set(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops;
 	errno_t      rc;
 	struct tm    t;
-	cap_call_handle_t cid;
+	cap_call_handle_t call_handle;
 	size_t       len;
 
-	if (!async_data_write_receive(&cid, &len)) {
+	if (!async_data_write_receive(&call_handle, &len)) {
 		/* TODO: Handle protocol error */
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -127,14 +127,14 @@
 	if (!clock_dev_ops->time_set) {
 		/* The driver does not support the time_set() functionality */
-		async_answer_0(cid, ENOTSUP);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(call_handle, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
-	async_data_write_finalize(cid, &t, sizeof(struct tm));
+	async_data_write_finalize(call_handle, &t, sizeof(struct tm));
 
 	rc = (*clock_dev_ops->time_set)(fun, &t);
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
Index: uspace/lib/drv/generic/remote_hw_res.c
===================================================================
--- uspace/lib/drv/generic/remote_hw_res.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_hw_res.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -69,10 +69,10 @@
 
 static void remote_hw_res_enable_interrupt(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
 
 	if (hw_res_ops->enable_interrupt == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -80,14 +80,14 @@
 	const int irq = DEV_IPC_GET_ARG1(*call);
 	const errno_t ret = hw_res_ops->enable_interrupt(fun, irq);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_hw_res_disable_interrupt(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
 
 	if (hw_res_ops->disable_interrupt == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -95,14 +95,14 @@
 	const int irq = DEV_IPC_GET_ARG1(*call);
 	const errno_t ret = hw_res_ops->disable_interrupt(fun, irq);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_hw_res_clear_interrupt(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
 
 	if (hw_res_ops->clear_interrupt == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -110,14 +110,14 @@
 	const int irq = DEV_IPC_GET_ARG1(*call);
 	const errno_t ret = hw_res_ops->enable_interrupt(fun, irq);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_hw_res_get_resource_list(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
 
 	if (hw_res_ops->get_resource_list == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -125,25 +125,25 @@
 	hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(fun);
 	if (hw_resources == NULL){
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
 
-	async_answer_1(callid, EOK, hw_resources->count);
+	async_answer_1(chandle, EOK, hw_resources->count);
 
 	size_t len;
-	if (!async_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&chandle, &len)) {
 		/* Protocol error - the recipient is not accepting data */
 		return;
 	}
-	async_data_read_finalize(callid, hw_resources->resources, len);
+	async_data_read_finalize(chandle, hw_resources->resources, len);
 }
 
 static void remote_hw_res_dma_channel_setup(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	hw_res_ops_t *hw_res_ops = ops;
 
 	if (hw_res_ops->dma_channel_setup == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -155,14 +155,14 @@
 	const errno_t ret = hw_res_ops->dma_channel_setup(
 	    fun, channel, address, size, mode);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_hw_res_dma_channel_remain(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	hw_res_ops_t *hw_res_ops = ops;
 
 	if (hw_res_ops->dma_channel_setup == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -170,5 +170,5 @@
 	size_t remain = 0;
 	const errno_t ret = hw_res_ops->dma_channel_remain(fun, channel, &remain);
-	async_answer_1(callid, ret, remain);
+	async_answer_1(chandle, ret, remain);
 }
 /**
Index: uspace/lib/drv/generic/remote_ieee80211.c
===================================================================
--- uspace/lib/drv/generic/remote_ieee80211.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_ieee80211.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -268,5 +268,5 @@
 
 static void remote_ieee80211_get_scan_results(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	ieee80211_iface_t *ieee80211_iface = (ieee80211_iface_t *) iface;
@@ -280,27 +280,27 @@
 	errno_t rc = ieee80211_iface->get_scan_results(fun, &scan_results, now);
 	if (rc == EOK) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t max_len;
-		if (!async_data_read_receive(&data_callid, &max_len)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &max_len)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (max_len < sizeof(ieee80211_scan_results_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
 			return;
 		}
 
-		async_data_read_finalize(data_callid, &scan_results,
+		async_data_read_finalize(data_chandle, &scan_results,
 		    sizeof(ieee80211_scan_results_t));
 	}
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_ieee80211_connect(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	ieee80211_iface_t *ieee80211_iface = (ieee80211_iface_t *) iface;
@@ -310,41 +310,41 @@
 	char password[MAX_STRING_SIZE];
 
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
-	if (!async_data_write_receive(&data_callid, &len)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+	if (!async_data_write_receive(&data_chandle, &len)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (len > MAX_STRING_SIZE) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_data_write_finalize(data_callid, ssid_start, len);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_data_write_finalize(data_chandle, ssid_start, len);
 	if (rc != EOK) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	if (!async_data_write_receive(&data_callid, &len)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	if (!async_data_write_receive(&data_chandle, &len)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (len > MAX_STRING_SIZE) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(data_callid, password, len);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(data_chandle, password, len);
 	if (rc != EOK) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -352,14 +352,14 @@
 	rc = ieee80211_iface->connect(fun, ssid_start, password);
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_ieee80211_disconnect(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	ieee80211_iface_t *ieee80211_iface = (ieee80211_iface_t *) iface;
 	assert(ieee80211_iface->disconnect);
 	errno_t rc = ieee80211_iface->disconnect(fun);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
Index: uspace/lib/drv/generic/remote_led_dev.c
===================================================================
--- uspace/lib/drv/generic/remote_led_dev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_led_dev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -66,5 +66,5 @@
  *
  */
-static void remote_led_color_set(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
+static void remote_led_color_set(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -73,10 +73,10 @@
 
 	if (!led_dev_ops->color_set) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = (*led_dev_ops->color_set)(fun, color);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
Index: uspace/lib/drv/generic/remote_nic.c
===================================================================
--- uspace/lib/drv/generic/remote_nic.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_nic.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1337,5 +1337,5 @@
 
 static void remote_nic_send_frame(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1348,15 +1348,15 @@
 	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 	if (rc != EOK) {
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	rc = nic_iface->send_frame(dev, data, size);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 	free(data);
 }
 
 static void remote_nic_callback_create(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1364,9 +1364,9 @@
 
 	errno_t rc = nic_iface->callback_create(dev);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_get_state(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1376,9 +1376,9 @@
 
 	errno_t rc = nic_iface->get_state(dev, &state);
-	async_answer_1(callid, rc, state);
+	async_answer_1(chandle, rc, state);
 }
 
 static void remote_nic_set_state(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1388,9 +1388,9 @@
 
 	errno_t rc = nic_iface->set_state(dev, state);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_get_address(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1403,48 +1403,48 @@
 	if (rc == EOK) {
 		size_t max_len;
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 
 		/* All errors will be translated into EPARTY anyway */
-		if (!async_data_read_receive(&data_callid, &max_len)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &max_len)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (max_len != sizeof(nic_address_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_callid, &address,
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(data_chandle, &address,
 		    sizeof(nic_address_t));
 	}
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_set_address(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	size_t length;
-	cap_call_handle_t data_callid;
-	if (!async_data_write_receive(&data_callid, &length)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t data_chandle;
+	if (!async_data_write_receive(&data_chandle, &length)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (length > sizeof(nic_address_t)) {
-		async_answer_0(data_callid, ELIMIT);
-		async_answer_0(callid, ELIMIT);
+		async_answer_0(data_chandle, ELIMIT);
+		async_answer_0(chandle, ELIMIT);
 		return;
 	}
 
 	nic_address_t address;
-	if (async_data_write_finalize(data_callid, &address, length) != EOK) {
-		async_answer_0(callid, EINVAL);
+	if (async_data_write_finalize(data_chandle, &address, length) != EOK) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -1452,15 +1452,15 @@
 	if (nic_iface->set_address != NULL) {
 		errno_t rc = nic_iface->set_address(dev, &address);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	} else
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 }
 
 static void remote_nic_get_stats(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_stats == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1471,31 +1471,31 @@
 	errno_t rc = nic_iface->get_stats(dev, &stats);
 	if (rc == EOK) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t max_len;
-		if (!async_data_read_receive(&data_callid, &max_len)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &max_len)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (max_len < sizeof(nic_device_stats_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_callid, &stats,
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(data_chandle, &stats,
 		    sizeof(nic_device_stats_t));
 	}
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_get_device_info(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_device_info == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1506,31 +1506,31 @@
 	errno_t rc = nic_iface->get_device_info(dev, &info);
 	if (rc == EOK) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t max_len;
-		if (!async_data_read_receive(&data_callid, &max_len)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &max_len)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (max_len < sizeof (nic_device_info_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_callid, &info,
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(data_chandle, &info,
 		    sizeof(nic_device_info_t));
 	}
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_get_cable_state(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_cable_state == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1539,13 +1539,13 @@
 
 	errno_t rc = nic_iface->get_cable_state(dev, &cs);
-	async_answer_1(callid, rc, (sysarg_t) cs);
+	async_answer_1(chandle, rc, (sysarg_t) cs);
 }
 
 static void remote_nic_get_operation_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_operation_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1556,14 +1556,14 @@
 
 	errno_t rc = nic_iface->get_operation_mode(dev, &speed, &duplex, &role);
-	async_answer_3(callid, rc, (sysarg_t) speed, (sysarg_t) duplex,
+	async_answer_3(chandle, rc, (sysarg_t) speed, (sysarg_t) duplex,
 	    (sysarg_t) role);
 }
 
 static void remote_nic_set_operation_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->set_operation_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1574,13 +1574,13 @@
 
 	errno_t rc = nic_iface->set_operation_mode(dev, speed, duplex, role);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_autoneg_enable(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_enable == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1589,26 +1589,26 @@
 
 	errno_t rc = nic_iface->autoneg_enable(dev, advertisement);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_autoneg_disable(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_disable == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = nic_iface->autoneg_disable(dev);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_autoneg_probe(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_probe == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1621,27 +1621,27 @@
 	errno_t rc = nic_iface->autoneg_probe(dev, &our_adv, &their_adv, &result,
 	    &their_result);
-	async_answer_4(callid, rc, our_adv, their_adv, (sysarg_t) result,
+	async_answer_4(chandle, rc, our_adv, their_adv, (sysarg_t) result,
 	    (sysarg_t) their_result);
 }
 
 static void remote_nic_autoneg_restart(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_restart == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = nic_iface->autoneg_restart(dev);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_get_pause(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_pause == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1652,13 +1652,13 @@
 
 	errno_t rc = nic_iface->get_pause(dev, &we_send, &we_receive, &pause);
-	async_answer_3(callid, rc, we_send, we_receive, pause);
+	async_answer_3(chandle, rc, we_send, we_receive, pause);
 }
 
 static void remote_nic_set_pause(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->set_pause == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1670,13 +1670,13 @@
 	errno_t rc = nic_iface->set_pause(dev, allow_send, allow_receive,
 	    pause);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_unicast_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->unicast_get_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1688,5 +1688,5 @@
 		address_list = malloc(max_count * sizeof (nic_address_t));
 		if (!address_list) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return;
 		}
@@ -1702,13 +1702,13 @@
 	if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
 		free(address_list);
-		async_answer_2(callid, rc, mode, address_count);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_2(chandle, rc, mode, address_count);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t max_len;
-	if (!async_data_read_receive(&data_callid, &max_len)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_2(callid, rc, mode, address_count);
+	if (!async_data_read_receive(&data_chandle, &max_len)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_2(chandle, rc, mode, address_count);
 		free(address_list);
 		return;
@@ -1721,13 +1721,13 @@
 		max_len = max_count * sizeof(nic_address_t);
 
-	async_data_read_finalize(data_callid, address_list, max_len);
-	async_answer_0(data_callid, EINVAL);
+	async_data_read_finalize(data_chandle, address_list, max_len);
+	async_answer_0(data_chandle, EINVAL);
 
 	free(address_list);
-	async_answer_2(callid, rc, mode, address_count);
+	async_answer_2(chandle, rc, mode, address_count);
 }
 
 static void remote_nic_unicast_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1739,14 +1739,14 @@
 
 	if (address_count) {
-		cap_call_handle_t data_callid;
-		if (!async_data_write_receive(&data_callid, &length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		cap_call_handle_t data_chandle;
+		if (!async_data_write_receive(&data_chandle, &length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (length != address_count * sizeof(nic_address_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
 			return;
 		}
@@ -1754,12 +1754,12 @@
 		address_list = malloc(length);
 		if (address_list == NULL) {
-			async_answer_0(data_callid, ENOMEM);
-			async_answer_0(callid, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_callid, address_list,
+			async_answer_0(data_chandle, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(data_chandle, address_list,
 		    length) != EOK) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(address_list);
 			return;
@@ -1770,7 +1770,7 @@
 		errno_t rc = nic_iface->unicast_set_mode(dev, mode, address_list,
 		    address_count);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	} else
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 
 	free(address_list);
@@ -1778,9 +1778,9 @@
 
 static void remote_nic_multicast_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->multicast_get_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1792,5 +1792,5 @@
 		address_list = malloc(max_count * sizeof(nic_address_t));
 		if (!address_list) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return;
 		}
@@ -1807,13 +1807,13 @@
 	if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
 		free(address_list);
-		async_answer_2(callid, rc, mode, address_count);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_2(chandle, rc, mode, address_count);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t max_len;
-	if (!async_data_read_receive(&data_callid, &max_len)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_2(callid, rc, mode, address_count);
+	if (!async_data_read_receive(&data_chandle, &max_len)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_2(chandle, rc, mode, address_count);
 		free(address_list);
 		return;
@@ -1826,12 +1826,12 @@
 		max_len = max_count * sizeof(nic_address_t);
 
-	async_data_read_finalize(data_callid, address_list, max_len);
+	async_data_read_finalize(data_chandle, address_list, max_len);
 
 	free(address_list);
-	async_answer_2(callid, rc, mode, address_count);
+	async_answer_2(chandle, rc, mode, address_count);
 }
 
 static void remote_nic_multicast_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1842,15 +1842,15 @@
 
 	if (address_count) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t length;
-		if (!async_data_write_receive(&data_callid, &length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_write_receive(&data_chandle, &length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (length != address_count * sizeof (nic_address_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
 			return;
 		}
@@ -1858,12 +1858,12 @@
 		address_list = malloc(length);
 		if (address_list == NULL) {
-			async_answer_0(data_callid, ENOMEM);
-			async_answer_0(callid, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_callid, address_list,
+			async_answer_0(data_chandle, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(data_chandle, address_list,
 		    length) != EOK) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(address_list);
 			return;
@@ -1874,7 +1874,7 @@
 		errno_t rc = nic_iface->multicast_set_mode(dev, mode, address_list,
 		    address_count);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	} else
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 
 	free(address_list);
@@ -1882,9 +1882,9 @@
 
 static void remote_nic_broadcast_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->broadcast_get_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1893,13 +1893,13 @@
 
 	errno_t rc = nic_iface->broadcast_get_mode(dev, &mode);
-	async_answer_1(callid, rc, mode);
+	async_answer_1(chandle, rc, mode);
 }
 
 static void remote_nic_broadcast_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->broadcast_set_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1908,13 +1908,13 @@
 
 	errno_t rc = nic_iface->broadcast_set_mode(dev, mode);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_defective_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->defective_get_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1923,13 +1923,13 @@
 
 	errno_t rc = nic_iface->defective_get_mode(dev, &mode);
-	async_answer_1(callid, rc, mode);
+	async_answer_1(chandle, rc, mode);
 }
 
 static void remote_nic_defective_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->defective_set_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1938,13 +1938,13 @@
 
 	errno_t rc = nic_iface->defective_set_mode(dev, mode);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_blocked_sources_get(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->blocked_sources_get == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -1956,5 +1956,5 @@
 		address_list = malloc(max_count * sizeof(nic_address_t));
 		if (!address_list) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return;
 		}
@@ -1968,14 +1968,14 @@
 
 	if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
-		async_answer_1(callid, rc, address_count);
+		async_answer_1(chandle, rc, address_count);
 		free(address_list);
 		return;
 	}
 
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t max_len;
-	if (!async_data_read_receive(&data_callid, &max_len)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_1(callid, rc, address_count);
+	if (!async_data_read_receive(&data_chandle, &max_len)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_1(chandle, rc, address_count);
 		free(address_list);
 		return;
@@ -1988,13 +1988,13 @@
 		max_len = max_count * sizeof(nic_address_t);
 
-	async_data_read_finalize(data_callid, address_list, max_len);
-	async_answer_0(data_callid, EINVAL);
+	async_data_read_finalize(data_chandle, address_list, max_len);
+	async_answer_0(data_chandle, EINVAL);
 
 	free(address_list);
-	async_answer_1(callid, rc, address_count);
+	async_answer_1(chandle, rc, address_count);
 }
 
 static void remote_nic_blocked_sources_set(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -2005,14 +2005,14 @@
 
 	if (address_count) {
-		cap_call_handle_t data_callid;
-		if (!async_data_write_receive(&data_callid, &length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		cap_call_handle_t data_chandle;
+		if (!async_data_write_receive(&data_chandle, &length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (length != address_count * sizeof(nic_address_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
 			return;
 		}
@@ -2020,12 +2020,12 @@
 		address_list = malloc(length);
 		if (address_list == NULL) {
-			async_answer_0(data_callid, ENOMEM);
-			async_answer_0(callid, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_callid, address_list,
+			async_answer_0(data_chandle, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(data_chandle, address_list,
 		    length) != EOK) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(address_list);
 			return;
@@ -2036,7 +2036,7 @@
 		errno_t rc = nic_iface->blocked_sources_set(dev, address_list,
 		    address_count);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	} else
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 
 	free(address_list);
@@ -2044,9 +2044,9 @@
 
 static void remote_nic_vlan_get_mask(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->vlan_get_mask == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2057,26 +2057,26 @@
 	errno_t rc = nic_iface->vlan_get_mask(dev, &vlan_mask);
 	if (rc == EOK) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t max_len;
-		if (!async_data_read_receive(&data_callid, &max_len)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &max_len)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (max_len != sizeof(nic_vlan_mask_t)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
-			return;
-		}
-
-		async_data_read_finalize(data_callid, &vlan_mask, max_len);
-	}
-
-	async_answer_0(callid, rc);
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
+			return;
+		}
+
+		async_data_read_finalize(data_chandle, &vlan_mask, max_len);
+	}
+
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_vlan_set_mask(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -2087,21 +2087,21 @@
 
 	if (vlan_mask_set) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t length;
-		if (!async_data_write_receive(&data_callid, &length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_write_receive(&data_chandle, &length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (length != sizeof(nic_vlan_mask_t)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
-			return;
-		}
-
-		if (async_data_write_finalize(data_callid, &vlan_mask,
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
+			return;
+		}
+
+		if (async_data_write_finalize(data_chandle, &vlan_mask,
 		    length) != EOK) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
@@ -2112,16 +2112,16 @@
 	if (nic_iface->vlan_set_mask != NULL) {
 		errno_t rc = nic_iface->vlan_set_mask(dev, vlan_mask_pointer);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	} else
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 }
 
 static void remote_nic_vlan_set_tag(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	if (nic_iface->vlan_set_tag == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2132,22 +2132,22 @@
 
 	errno_t rc = nic_iface->vlan_set_tag(dev, tag, add, strip);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_wol_virtue_add(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	int send_data = (int) IPC_GET_ARG3(*call);
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 
 	if (nic_iface->wol_virtue_add == NULL) {
 		if (send_data) {
-			async_data_write_receive(&data_callid, NULL);
-			async_answer_0(data_callid, ENOTSUP);
-		}
-
-		async_answer_0(callid, ENOTSUP);
+			async_data_write_receive(&data_chandle, NULL);
+			async_answer_0(data_chandle, ENOTSUP);
+		}
+
+		async_answer_0(chandle, ENOTSUP);
 	}
 
@@ -2156,7 +2156,7 @@
 
 	if (send_data) {
-		if (!async_data_write_receive(&data_callid, &length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_write_receive(&data_chandle, &length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
@@ -2164,12 +2164,12 @@
 		data = malloc(length);
 		if (data == NULL) {
-			async_answer_0(data_callid, ENOMEM);
-			async_answer_0(callid, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_callid, data,
+			async_answer_0(data_chandle, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(data_chandle, data,
 		    length) != EOK) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(data);
 			return;
@@ -2181,15 +2181,15 @@
 
 	errno_t rc = nic_iface->wol_virtue_add(dev, type, data, length, &id);
-	async_answer_1(callid, rc, (sysarg_t) id);
+	async_answer_1(chandle, rc, (sysarg_t) id);
 	free(data);
 }
 
 static void remote_nic_wol_virtue_remove(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	if (nic_iface->wol_virtue_remove == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2198,14 +2198,14 @@
 
 	errno_t rc = nic_iface->wol_virtue_remove(dev, id);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_wol_virtue_probe(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	if (nic_iface->wol_virtue_probe == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2215,5 +2215,5 @@
 	nic_wv_type_t type = NIC_WV_NONE;
 	size_t length = 0;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	void *data = NULL;
 
@@ -2221,5 +2221,5 @@
 		data = malloc(max_length);
 		if (data == NULL) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return;
 		}
@@ -2233,7 +2233,7 @@
 	if ((max_length != 0) && (length != 0)) {
 		size_t req_length;
-		if (!async_data_read_receive(&data_callid, &req_length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &req_length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(data);
 			return;
@@ -2246,17 +2246,17 @@
 			req_length = max_length;
 
-		async_data_read_finalize(data_callid, data, req_length);
-	}
-
-	async_answer_2(callid, rc, (sysarg_t) type, (sysarg_t) length);
+		async_data_read_finalize(data_chandle, data, req_length);
+	}
+
+	async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) length);
 	free(data);
 }
 
 static void remote_nic_wol_virtue_list(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->wol_virtue_list == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2266,10 +2266,10 @@
 	size_t count = 0;
 	nic_wv_id_t *id_list = NULL;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 
 	if (max_count != 0) {
 		id_list = malloc(max_count * sizeof(nic_wv_id_t));
 		if (id_list == NULL) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return;
 		}
@@ -2283,7 +2283,7 @@
 	if ((max_count != 0) && (count != 0)) {
 		size_t req_length;
-		if (!async_data_read_receive(&data_callid, &req_length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &req_length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(id_list);
 			return;
@@ -2296,17 +2296,17 @@
 			req_length = max_count * sizeof(nic_wv_id_t);
 
-		rc = async_data_read_finalize(data_callid, id_list, req_length);
-	}
-
-	async_answer_1(callid, rc, (sysarg_t) count);
+		rc = async_data_read_finalize(data_chandle, id_list, req_length);
+	}
+
+	async_answer_1(chandle, rc, (sysarg_t) count);
 	free(id_list);
 }
 
 static void remote_nic_wol_virtue_get_caps(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->wol_virtue_get_caps == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2316,13 +2316,13 @@
 
 	errno_t rc = nic_iface->wol_virtue_get_caps(dev, type, &count);
-	async_answer_1(callid, rc, (sysarg_t) count);
+	async_answer_1(chandle, rc, (sysarg_t) count);
 }
 
 static void remote_nic_wol_load_info(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->wol_load_info == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2336,5 +2336,5 @@
 		data = malloc(max_length);
 		if (data == NULL) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return;
 		}
@@ -2346,9 +2346,9 @@
 	    &frame_length);
 	if (rc == EOK) {
-		cap_call_handle_t data_callid;
+		cap_call_handle_t data_chandle;
 		size_t req_length;
-		if (!async_data_read_receive(&data_callid, &req_length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&data_chandle, &req_length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			free(data);
 			return;
@@ -2357,17 +2357,17 @@
 		req_length = req_length > max_length ? max_length : req_length;
 		req_length = req_length > frame_length ? frame_length : req_length;
-		async_data_read_finalize(data_callid, data, req_length);
-	}
-
-	async_answer_2(callid, rc, (sysarg_t) type, (sysarg_t) frame_length);
+		async_data_read_finalize(data_chandle, data, req_length);
+	}
+
+	async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) frame_length);
 	free(data);
 }
 
 static void remote_nic_offload_probe(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->offload_probe == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2377,13 +2377,13 @@
 
 	errno_t rc = nic_iface->offload_probe(dev, &supported, &active);
-	async_answer_2(callid, rc, supported, active);
+	async_answer_2(chandle, rc, supported, active);
 }
 
 static void remote_nic_offload_set(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->offload_set == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2393,13 +2393,13 @@
 
 	errno_t rc = nic_iface->offload_set(dev, mask, active);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
 static void remote_nic_poll_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->poll_get_mode == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -2415,27 +2415,27 @@
 	if ((rc == EOK) && (request_data)) {
 		size_t max_len;
-		cap_call_handle_t data_callid;
-
-		if (!async_data_read_receive(&data_callid, &max_len)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		cap_call_handle_t data_chandle;
+
+		if (!async_data_read_receive(&data_chandle, &max_len)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (max_len != sizeof(struct timeval)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_callid, &period,
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(data_chandle, &period,
 		    sizeof(struct timeval));
 	}
 
-	async_answer_1(callid, rc, (sysarg_t) mode);
+	async_answer_1(chandle, rc, (sysarg_t) mode);
 }
 
 static void remote_nic_poll_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -2448,21 +2448,21 @@
 
 	if (has_period) {
-		cap_call_handle_t data_callid;
-		if (!async_data_write_receive(&data_callid, &length)) {
-			async_answer_0(data_callid, EINVAL);
-			async_answer_0(callid, EINVAL);
+		cap_call_handle_t data_chandle;
+		if (!async_data_write_receive(&data_chandle, &length)) {
+			async_answer_0(data_chandle, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
 
 		if (length != sizeof(struct timeval)) {
-			async_answer_0(data_callid, ELIMIT);
-			async_answer_0(callid, ELIMIT);
+			async_answer_0(data_chandle, ELIMIT);
+			async_answer_0(chandle, ELIMIT);
 			return;
 		}
 
 		period = &period_buf;
-		if (async_data_write_finalize(data_callid, period,
+		if (async_data_write_finalize(data_chandle, period,
 		    length) != EOK) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
@@ -2471,20 +2471,20 @@
 	if (nic_iface->poll_set_mode != NULL) {
 		errno_t rc = nic_iface->poll_set_mode(dev, mode, period);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 	} else
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 }
 
 static void remote_nic_poll_now(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->poll_now == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = nic_iface->poll_now(dev);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
Index: uspace/lib/drv/generic/remote_pci.c
===================================================================
--- uspace/lib/drv/generic/remote_pci.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_pci.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -150,10 +150,10 @@
 };
 
-void remote_config_space_read_8(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+void remote_config_space_read_8(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(iface);
 	pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
 	if (pci_iface->config_space_read_8 == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -162,16 +162,16 @@
 	errno_t ret = pci_iface->config_space_read_8(fun, address, &value);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-	} else {
-		async_answer_1(callid, EOK, value);
-	}
-}
-
-void remote_config_space_read_16(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, ret);
+	} else {
+		async_answer_1(chandle, EOK, value);
+	}
+}
+
+void remote_config_space_read_16(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(iface);
 	pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
 	if (pci_iface->config_space_read_16 == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -180,15 +180,15 @@
 	errno_t ret = pci_iface->config_space_read_16(fun, address, &value);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-	} else {
-		async_answer_1(callid, EOK, value);
-	}
-}
-void remote_config_space_read_32(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, ret);
+	} else {
+		async_answer_1(chandle, EOK, value);
+	}
+}
+void remote_config_space_read_32(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(iface);
 	pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
 	if (pci_iface->config_space_read_32 == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -197,16 +197,16 @@
 	errno_t ret = pci_iface->config_space_read_32(fun, address, &value);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-	} else {
-		async_answer_1(callid, EOK, value);
-	}
-}
-
-void remote_config_space_write_8(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, ret);
+	} else {
+		async_answer_1(chandle, EOK, value);
+	}
+}
+
+void remote_config_space_write_8(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(iface);
 	pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
 	if (pci_iface->config_space_write_8 == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -215,16 +215,16 @@
 	errno_t ret = pci_iface->config_space_write_8(fun, address, value);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-	} else {
-		async_answer_0(callid, EOK);
-	}
-}
-
-void remote_config_space_write_16(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, ret);
+	} else {
+		async_answer_0(chandle, EOK);
+	}
+}
+
+void remote_config_space_write_16(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(iface);
 	pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
 	if (pci_iface->config_space_write_16 == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -233,16 +233,16 @@
 	errno_t ret = pci_iface->config_space_write_16(fun, address, value);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-	} else {
-		async_answer_0(callid, EOK);
-	}
-}
-
-void remote_config_space_write_32(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, ret);
+	} else {
+		async_answer_0(chandle, EOK);
+	}
+}
+
+void remote_config_space_write_32(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(iface);
 	pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
 	if (pci_iface->config_space_write_32 == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -251,7 +251,7 @@
 	errno_t ret = pci_iface->config_space_write_32(fun, address, value);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-	} else {
-		async_answer_0(callid, EOK);
+		async_answer_0(chandle, ret);
+	} else {
+		async_answer_0(chandle, EOK);
 	}
 }
Index: uspace/lib/drv/generic/remote_pio_window.c
===================================================================
--- uspace/lib/drv/generic/remote_pio_window.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_pio_window.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -53,5 +53,5 @@
 
 static void remote_pio_window_get(ddf_fun_t *fun, void *ops,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	pio_window_ops_t *pio_win_ops = (pio_window_ops_t *) ops;
@@ -59,5 +59,5 @@
 
 	if (!pio_win_ops->get_pio_window) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -65,16 +65,16 @@
 	pio_window_t *pio_window = pio_win_ops->get_pio_window(fun);
 	if (!pio_window) {
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
 
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 
-	if (!async_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&chandle, &len)) {
 		/* Protocol error - the recipient is not accepting data */
 		return;
 	}
 
-	async_data_read_finalize(callid, pio_window, len);
+	async_data_read_finalize(chandle, pio_window, len);
 }
 
Index: uspace/lib/drv/generic/remote_usb.c
===================================================================
--- uspace/lib/drv/generic/remote_usb.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_usb.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -107,10 +107,10 @@
 
 void remote_usb_get_my_description(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usb_iface_t *usb_iface = (usb_iface_t *) iface;
 
 	if (usb_iface->get_my_description == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -119,7 +119,7 @@
 	const errno_t ret = usb_iface->get_my_description(fun, &desc);
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
+		async_answer_0(chandle, ret);
 	} else {
-		async_answer_5(callid, EOK,
+		async_answer_5(chandle, EOK,
 		    (sysarg_t) desc.address,
 		    (sysarg_t) desc.depth,
Index: uspace/lib/drv/generic/remote_usbdiag.c
===================================================================
--- uspace/lib/drv/generic/remote_usbdiag.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_usbdiag.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -144,25 +144,25 @@
 
 void remote_usbdiag_test_in(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
 
 	size_t size;
-	cap_call_handle_t data_callid;
-	if (!async_data_write_receive(&data_callid, &size)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t data_chandle;
+	if (!async_data_write_receive(&data_chandle, &size)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(usbdiag_test_params_t)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	usbdiag_test_params_t params;
-	if (async_data_write_finalize(data_callid, &params, size) != EOK) {
-		async_answer_0(callid, EINVAL);
+	if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -173,50 +173,50 @@
 
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-		return;
-	}
-
-	if (!async_data_read_receive(&data_callid, &size)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, ret);
+		return;
+	}
+
+	if (!async_data_read_receive(&data_chandle, &size)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(usbdiag_test_results_t)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	if (async_data_read_finalize(data_callid, &results, size) != EOK) {
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	async_answer_0(callid, ret);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	if (async_data_read_finalize(data_chandle, &results, size) != EOK) {
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	async_answer_0(chandle, ret);
 }
 
 void remote_usbdiag_test_out(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
 
 	size_t size;
-	cap_call_handle_t data_callid;
-	if (!async_data_write_receive(&data_callid, &size)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t data_chandle;
+	if (!async_data_write_receive(&data_chandle, &size)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(usbdiag_test_params_t)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	usbdiag_test_params_t params;
-	if (async_data_write_finalize(data_callid, &params, size) != EOK) {
-		async_answer_0(callid, EINVAL);
+	if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -227,26 +227,26 @@
 
 	if (ret != EOK) {
-		async_answer_0(callid, ret);
-		return;
-	}
-
-	if (!async_data_read_receive(&data_callid, &size)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, ret);
+		return;
+	}
+
+	if (!async_data_read_receive(&data_chandle, &size)) {
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(usbdiag_test_results_t)) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	if (async_data_read_finalize(data_callid, &results, size) != EOK) {
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-
-	async_answer_0(callid, ret);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	if (async_data_read_finalize(data_chandle, &results, size) != EOK) {
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+
+	async_answer_0(chandle, ret);
 }
 
Index: uspace/lib/drv/generic/remote_usbhc.c
===================================================================
--- uspace/lib/drv/generic/remote_usbhc.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_usbhc.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -232,5 +232,5 @@
 static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
 static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
-static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call);
+static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call);
 
 /** Remote USB interface operations. */
@@ -257,10 +257,10 @@
 
 void remote_usbhc_default_address_reservation(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
 
 	if (usbhc_iface->default_address_reservation == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -268,15 +268,15 @@
 	const bool reserve = IPC_GET_ARG2(*call);
 	const errno_t ret = usbhc_iface->default_address_reservation(fun, reserve);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 
 static void remote_usbhc_device_enumerate(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
 
 	if (usbhc_iface->device_enumerate == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -285,14 +285,14 @@
 	usb_speed_t speed = DEV_IPC_GET_ARG2(*call);
 	const errno_t ret = usbhc_iface->device_enumerate(fun, port, speed);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_usbhc_device_remove(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
 
 	if (usbhc_iface->device_remove == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -300,9 +300,9 @@
 	const unsigned port = DEV_IPC_GET_ARG1(*call);
 	const errno_t ret = usbhc_iface->device_remove(fun, port);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(fun);
@@ -313,33 +313,33 @@
 
 	if (!usbhc_iface->register_endpoint) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	usb_endpoint_descriptors_t ep_desc;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
 
-	if (!async_data_write_receive(&data_callid, &len)
+	if (!async_data_write_receive(&data_chandle, &len)
 	    || len != sizeof(ep_desc)) {
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-	async_data_write_finalize(data_callid, &ep_desc, sizeof(ep_desc));
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+	async_data_write_finalize(data_chandle, &ep_desc, sizeof(ep_desc));
 
 	usb_pipe_desc_t pipe_desc;
 
 	const errno_t rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
-	async_answer_0(callid, rc);
-
-	if (!async_data_read_receive(&data_callid, &len)
+	async_answer_0(chandle, rc);
+
+	if (!async_data_read_receive(&data_chandle, &len)
 	    || len != sizeof(pipe_desc)) {
 		return;
 	}
-	async_data_read_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+	async_data_read_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
 }
 
 static void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(fun);
@@ -350,21 +350,21 @@
 
 	if (!usbhc_iface->unregister_endpoint) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	usb_pipe_desc_t pipe_desc;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
 
-	if (!async_data_write_receive(&data_callid, &len)
+	if (!async_data_write_receive(&data_chandle, &len)
 	    || len != sizeof(pipe_desc)) {
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-	async_data_write_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+	async_data_write_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
 
 	const errno_t rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
@@ -410,17 +410,17 @@
 
 	errno_t err;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t size;
 	unsigned flags;
 
-	if (!async_share_out_receive(&data_callid, &size, &flags))
+	if (!async_share_out_receive(&data_chandle, &size, &flags))
 		return EPARTY;
 
 	if (size < required_size || (flags & required_flags) != required_flags) {
-		async_answer_0(data_callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
 		return EINVAL;
 	}
 
-	if ((err = async_share_out_finalize(data_callid, &trans->request.buffer.virt)))
+	if ((err = async_share_out_finalize(data_chandle, &trans->request.buffer.virt)))
 		return err;
 
@@ -445,5 +445,5 @@
 }
 
-void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(fun);
@@ -454,11 +454,11 @@
 
 	if (!usbhc_iface->transfer) {
-		async_answer_0(callid, ENOTSUP);
-		return;
-	}
-
-	async_transaction_t *trans = async_transaction_create(callid);
+		async_answer_0(chandle, ENOTSUP);
+		return;
+	}
+
+	async_transaction_t *trans = async_transaction_create(chandle);
 	if (trans == NULL) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -466,13 +466,13 @@
 	errno_t err = EPARTY;
 
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
-	if (!async_data_write_receive(&data_callid, &len)
+	if (!async_data_write_receive(&data_chandle, &len)
 	    || len != sizeof(trans->request)) {
-		async_answer_0(data_callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
 		goto err;
 	}
 
-	if ((err = async_data_write_finalize(data_callid,
+	if ((err = async_data_write_finalize(data_chandle,
 			    &trans->request, sizeof(trans->request))))
 		goto err;
@@ -494,5 +494,5 @@
 
 err:
-	async_answer_0(callid, err);
+	async_answer_0(chandle, err);
 	async_transaction_destroy(trans);
 }
Index: uspace/lib/drv/generic/remote_usbhid.c
===================================================================
--- uspace/lib/drv/generic/remote_usbhid.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/drv/generic/remote_usbhid.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -309,5 +309,5 @@
 
 void remote_usbhid_get_event_length(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	printf("remote_usbhid_get_event_length()\n");
@@ -317,5 +317,5 @@
 	if (!hid_iface->get_event_length) {
 		printf("Get event length not set!\n");
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -325,20 +325,20 @@
 //		len = EEMPTY;
 //	}
-	async_answer_1(callid, EOK, len);
+	async_answer_1(chandle, EOK, len);
 
 //	if (len < 0) {
-//		async_answer_0(callid, len);
+//		async_answer_0(chandle, len);
 //	} else {
-//		async_answer_1(callid, EOK, len);
+//		async_answer_1(chandle, EOK, len);
 //	}
 }
 
 void remote_usbhid_get_event(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
 
 	if (!hid_iface->get_event) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -347,7 +347,7 @@
 
 	size_t len;
-	cap_call_handle_t data_callid;
-	if (!async_data_read_receive(&data_callid, &len)) {
-		async_answer_0(callid, EPARTY);
+	cap_call_handle_t data_chandle;
+	if (!async_data_read_receive(&data_chandle, &len)) {
+		async_answer_0(chandle, EPARTY);
 		return;
 	}
@@ -357,6 +357,6 @@
 //	}
 	if (len == 0) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -366,6 +366,6 @@
 	uint8_t *data = malloc(len);
 	if (data == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -376,6 +376,6 @@
 	if (rc != EOK) {
 		free(data);
-		async_answer_0(data_callid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(data_chandle, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -386,45 +386,45 @@
 	}
 
-	async_data_read_finalize(data_callid, data, act_length);
+	async_data_read_finalize(data_chandle, data, act_length);
 
 	free(data);
 
-	async_answer_1(callid, EOK, event_nr);
+	async_answer_1(chandle, EOK, event_nr);
 }
 
 void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
 
 	if (!hid_iface->get_report_descriptor_length) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	size_t len = hid_iface->get_report_descriptor_length(fun);
-	async_answer_1(callid, EOK, (sysarg_t) len);
+	async_answer_1(chandle, EOK, (sysarg_t) len);
 }
 
 void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
 
 	if (!hid_iface->get_report_descriptor) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	size_t len;
-	cap_call_handle_t data_callid;
-	if (!async_data_read_receive(&data_callid, &len)) {
-		async_answer_0(callid, EINVAL);
+	cap_call_handle_t data_chandle;
+	if (!async_data_read_receive(&data_chandle, &len)) {
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	if (len == 0) {
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -432,6 +432,6 @@
 	uint8_t *descriptor = malloc(len);
 	if (descriptor == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -445,11 +445,11 @@
 	if (rc != EOK) {
 		free(descriptor);
-		async_answer_0(data_callid, rc);
-		async_answer_0(callid, rc);
-		return;
-	}
-
-	async_data_read_finalize(data_callid, descriptor, act_len);
-	async_answer_0(callid, EOK);
+		async_answer_0(data_chandle, rc);
+		async_answer_0(chandle, rc);
+		return;
+	}
+
+	async_data_read_finalize(data_chandle, descriptor, act_len);
+	async_answer_0(chandle, EOK);
 
 	free(descriptor);
Index: uspace/lib/ext4/src/ops.c
===================================================================
--- uspace/lib/ext4/src/ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/ext4/src/ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1021,8 +1021,8 @@
 	 * Receive the read request.
 	 */
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -1031,5 +1031,5 @@
 	errno_t rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 	}
@@ -1039,5 +1039,5 @@
 	rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 	}
@@ -1046,13 +1046,13 @@
 	if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
 	    EXT4_INODE_MODE_FILE)) {
-		rc = ext4_read_file(callid, pos, size, inst, inode_ref,
+		rc = ext4_read_file(chandle, pos, size, inst, inode_ref,
 		    rbytes);
 	} else if (ext4_inode_is_type(inst->filesystem->superblock,
 	    inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) {
-		rc = ext4_read_directory(callid, pos, size, inst, inode_ref,
+		rc = ext4_read_directory(chandle, pos, size, inst, inode_ref,
 		    rbytes);
 	} else {
 		/* Other inode types not supported */
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		rc = ENOTSUP;
 	}
@@ -1084,5 +1084,5 @@
 /** Read data from directory.
  *
- * @param callid    IPC id of call (for communication)
+ * @param chandle    IPC id of call (for communication)
  * @param pos       Position to start reading from
  * @param size      How many bytes to read
@@ -1094,5 +1094,5 @@
  *
  */
-errno_t ext4_read_directory(cap_call_handle_t callid, aoff64_t pos, size_t size,
+errno_t ext4_read_directory(cap_call_handle_t chandle, aoff64_t pos, size_t size,
     ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
 {
@@ -1100,5 +1100,5 @@
 	errno_t rc = ext4_directory_iterator_init(&it, inode_ref, pos);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 	}
@@ -1129,5 +1129,5 @@
 		if (buf == NULL) {
 			ext4_directory_iterator_fini(&it);
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return ENOMEM;
 		}
@@ -1137,5 +1137,5 @@
 		found = true;
 
-		(void) async_data_read_finalize(callid, buf, name_size + 1);
+		(void) async_data_read_finalize(chandle, buf, name_size + 1);
 		free(buf);
 		break;
@@ -1145,5 +1145,5 @@
 		if (rc != EOK) {
 			ext4_directory_iterator_fini(&it);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
@@ -1168,5 +1168,5 @@
 		return EOK;
 	} else {
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return ENOENT;
 	}
@@ -1175,5 +1175,5 @@
 /** Read data from file.
  *
- * @param callid    IPC id of call (for communication)
+ * @param chandle    IPC id of call (for communication)
  * @param pos       Position to start reading from
  * @param size      How many bytes to read
@@ -1185,5 +1185,5 @@
  *
  */
-errno_t ext4_read_file(cap_call_handle_t callid, aoff64_t pos, size_t size,
+errno_t ext4_read_file(cap_call_handle_t chandle, aoff64_t pos, size_t size,
     ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
 {
@@ -1193,5 +1193,5 @@
 	if (pos >= file_size) {
 		/* Read 0 bytes successfully */
-		async_data_read_finalize(callid, NULL, 0);
+		async_data_read_finalize(chandle, NULL, 0);
 		*rbytes = 0;
 		return EOK;
@@ -1213,5 +1213,5 @@
 	    file_block, &fs_block);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 	}
@@ -1227,5 +1227,5 @@
 		buffer = malloc(bytes);
 		if (buffer == NULL) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			return ENOMEM;
 		}
@@ -1233,5 +1233,5 @@
 		memset(buffer, 0, bytes);
 
-		rc = async_data_read_finalize(callid, buffer, bytes);
+		rc = async_data_read_finalize(chandle, buffer, bytes);
 		*rbytes = bytes;
 
@@ -1244,10 +1244,10 @@
 	rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 	}
 
 	assert(offset_in_block + bytes <= block_size);
-	rc = async_data_read_finalize(callid, block->data + offset_in_block, bytes);
+	rc = async_data_read_finalize(chandle, block->data + offset_in_block, bytes);
 	if (rc != EOK) {
 		block_put(block);
@@ -1283,9 +1283,9 @@
 		return rc;
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
-	if (!async_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&chandle, &len)) {
 		rc = EINVAL;
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		goto exit;
 	}
@@ -1311,5 +1311,5 @@
 	    &fblock);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		goto exit;
 	}
@@ -1328,5 +1328,5 @@
 				    &fblock, true);
 				if (rc != EOK) {
-					async_answer_0(callid, rc);
+					async_answer_0(chandle, rc);
 					goto exit;
 				}
@@ -1336,5 +1336,5 @@
 			    &fblock, false);
 			if (rc != EOK) {
-				async_answer_0(callid, rc);
+				async_answer_0(chandle, rc);
 				goto exit;
 			}
@@ -1342,5 +1342,5 @@
 			rc = ext4_balloc_alloc_block(inode_ref, &fblock);
 			if (rc != EOK) {
-				async_answer_0(callid, rc);
+				async_answer_0(chandle, rc);
 				goto exit;
 			}
@@ -1350,5 +1350,5 @@
 			if (rc != EOK) {
 				ext4_balloc_free_block(inode_ref, fblock);
-				async_answer_0(callid, rc);
+				async_answer_0(chandle, rc);
 				goto exit;
 			}
@@ -1363,5 +1363,5 @@
 	rc = block_get(&write_block, service_id, fblock, flags);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		goto exit;
 	}
@@ -1370,5 +1370,5 @@
 		memset(write_block->data, 0, block_size);
 
-	rc = async_data_write_finalize(callid, write_block->data +
+	rc = async_data_write_finalize(chandle, write_block->data +
 	    (pos % block_size), bytes);
 	if (rc != EOK) {
Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/fs/libfs.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -87,9 +87,9 @@
 	vfs_fs_probe_info_t info;
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if ((!async_data_read_receive(&callid, &size)) ||
+	if ((!async_data_read_receive(&chandle, &size)) ||
 	    (size != sizeof(info))) {
-		async_answer_0(callid, EIO);
+		async_answer_0(chandle, EIO);
 		async_answer_0(rid, EIO);
 		return;
@@ -99,10 +99,10 @@
 	rc = vfs_out_ops->fsprobe(service_id, &info);
 	if (rc != EOK) {
-		async_answer_0(callid, EIO);
+		async_answer_0(chandle, EIO);
 		async_answer_0(rid, rc);
 		return;
 	}
 
-	async_data_read_finalize(callid, &info, sizeof(info));
+	async_data_read_finalize(chandle, &info, sizeof(info));
 	async_answer_0(rid, EOK);
 }
@@ -278,7 +278,7 @@
 }
 
-static void vfs_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	if (iid) {
+static void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	if (icall_handle) {
 		/*
 		 * This only happens for connections opened by
@@ -286,10 +286,10 @@
 		 * created by IPC_M_CONNECT_TO_ME.
 		 */
-		async_answer_0(iid, EOK);
+		async_answer_0(icall_handle, EOK);
 	}
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -298,50 +298,50 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case VFS_OUT_FSPROBE:
-			vfs_out_fsprobe(callid, &call);
+			vfs_out_fsprobe(chandle, &call);
 			break;
 		case VFS_OUT_MOUNTED:
-			vfs_out_mounted(callid, &call);
+			vfs_out_mounted(chandle, &call);
 			break;
 		case VFS_OUT_UNMOUNTED:
-			vfs_out_unmounted(callid, &call);
+			vfs_out_unmounted(chandle, &call);
 			break;
 		case VFS_OUT_LINK:
-			vfs_out_link(callid, &call);
+			vfs_out_link(chandle, &call);
 			break;
 		case VFS_OUT_LOOKUP:
-			vfs_out_lookup(callid, &call);
+			vfs_out_lookup(chandle, &call);
 			break;
 		case VFS_OUT_READ:
-			vfs_out_read(callid, &call);
+			vfs_out_read(chandle, &call);
 			break;
 		case VFS_OUT_WRITE:
-			vfs_out_write(callid, &call);
+			vfs_out_write(chandle, &call);
 			break;
 		case VFS_OUT_TRUNCATE:
-			vfs_out_truncate(callid, &call);
+			vfs_out_truncate(chandle, &call);
 			break;
 		case VFS_OUT_CLOSE:
-			vfs_out_close(callid, &call);
+			vfs_out_close(chandle, &call);
 			break;
 		case VFS_OUT_DESTROY:
-			vfs_out_destroy(callid, &call);
+			vfs_out_destroy(chandle, &call);
 			break;
 		case VFS_OUT_OPEN_NODE:
-			vfs_out_open_node(callid, &call);
+			vfs_out_open_node(chandle, &call);
 			break;
 		case VFS_OUT_STAT:
-			vfs_out_stat(callid, &call);
+			vfs_out_stat(chandle, &call);
 			break;
 		case VFS_OUT_SYNC:
-			vfs_out_sync(callid, &call);
+			vfs_out_sync(chandle, &call);
 			break;
 		case VFS_OUT_STATFS:
-			vfs_out_statfs(callid, &call);
+			vfs_out_statfs(chandle, &call);
 			break;
 		case VFS_OUT_IS_EMPTY:
-			vfs_out_is_empty(callid, &call);
+			vfs_out_is_empty(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
@@ -730,10 +730,10 @@
 	on_error(rc, answer_and_return(rid, rc));
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if ((!async_data_read_receive(&callid, &size)) ||
+	if ((!async_data_read_receive(&chandle, &size)) ||
 	    (size != sizeof(vfs_stat_t))) {
 		ops->node_put(fn);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		async_answer_0(rid, EINVAL);
 		return;
@@ -755,5 +755,5 @@
 
 
-	async_data_read_finalize(callid, &stat, sizeof(vfs_stat_t));
+	async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t));
 	async_answer_0(rid, EOK);
 }
@@ -769,7 +769,7 @@
 	on_error(rc, answer_and_return(rid, rc));
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if ((!async_data_read_receive(&callid, &size)) ||
+	if ((!async_data_read_receive(&chandle, &size)) ||
 	    (size != sizeof(vfs_statfs_t))) {
 		goto error;
@@ -800,5 +800,5 @@
 
 	ops->node_put(fn);
-	async_data_read_finalize(callid, &st, sizeof(vfs_statfs_t));
+	async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t));
 	async_answer_0(rid, EOK);
 	return;
@@ -806,5 +806,5 @@
 error:
 	ops->node_put(fn);
-	async_answer_0(callid, EINVAL);
+	async_answer_0(chandle, EINVAL);
 	async_answer_0(rid, EINVAL);
 }
Index: uspace/lib/graph/graph.c
===================================================================
--- uspace/lib/graph/graph.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/graph/graph.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -239,12 +239,12 @@
 }
 
-static void vs_claim(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
+static void vs_claim(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	vs->client_side_handle = IPC_GET_ARG1(*icall);
 	errno_t rc = vs->ops.claim(vs);
-	async_answer_0(iid, rc);
-}
-
-static void vs_yield(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void vs_yield(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	/* Deallocate resources for the current mode. */
@@ -264,15 +264,15 @@
 		vs->mode_set = false;
 
-	async_answer_0(iid, rc);
-}
-
-static void vs_enumerate_modes(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	async_answer_0(icall_handle, rc);
+}
+
+static void vs_enumerate_modes(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t len;
 
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -285,9 +285,9 @@
 		    list_get_instance(link, vslmode_list_element_t, link);
 
-		errno_t rc = async_data_read_finalize(callid, &mode_elem->mode, len);
-		async_answer_0(iid, rc);
+		errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
+		async_answer_0(icall_handle, rc);
 	} else {
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 	}
 
@@ -295,12 +295,12 @@
 }
 
-static void vs_get_default_mode(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void vs_get_default_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t len;
 
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -317,10 +317,10 @@
 
 	if (mode_elem != NULL) {
-		errno_t rc = async_data_read_finalize(callid, &mode_elem->mode, len);
-		async_answer_0(iid, rc);
+		errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
+		async_answer_0(icall_handle, rc);
 	} else {
 		fibril_mutex_unlock(&vs->mode_mtx);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 	}
 
@@ -328,32 +328,32 @@
 }
 
-static void vs_get_current_mode(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void vs_get_current_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t len;
 
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (vs->mode_set) {
-		errno_t rc = async_data_read_finalize(callid, &vs->cur_mode, len);
-		async_answer_0(iid, rc);
+		errno_t rc = async_data_read_finalize(chandle, &vs->cur_mode, len);
+		async_answer_0(icall_handle, rc);
 	} else {
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
-	}
-}
-
-static void vs_get_mode(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
+	}
+}
+
+static void vs_get_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t len;
 
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -372,9 +372,9 @@
 
 	if (mode_elem != NULL) {
-		errno_t rc = async_data_read_finalize(callid, &mode_elem->mode, len);
-		async_answer_0(iid, rc);
+		errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
+		async_answer_0(icall_handle, rc);
 	} else {
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 	}
 
@@ -382,14 +382,14 @@
 }
 
-static void vs_set_mode(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void vs_set_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	unsigned int flags;
 
 	/* Retrieve the shared cell storage for the new mode. */
-	if (!async_share_out_receive(&callid, &size, &flags)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_share_out_receive(&chandle, &size, &flags)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -412,6 +412,6 @@
 	if (mode_elem == NULL) {
 		fibril_mutex_unlock(&vs->mode_mtx);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -423,13 +423,13 @@
 	/* Check whether the mode is still up-to-date. */
 	if (new_mode.version != mode_version) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	void *new_cell_storage;
-	errno_t rc = async_share_out_finalize(callid, &new_cell_storage);
+	errno_t rc = async_share_out_finalize(chandle, &new_cell_storage);
 	if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -441,5 +441,5 @@
 	if (rc != EOK) {
 		as_area_destroy(new_cell_storage);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -464,8 +464,8 @@
 	vs->mode_set = true;
 
-	async_answer_0(iid, EOK);
-}
-
-static void vs_update_damaged_region(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vs_update_damaged_region(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t x_offset = (IPC_GET_ARG5(*icall) >> 16);
@@ -476,48 +476,48 @@
 	    IPC_GET_ARG3(*icall), IPC_GET_ARG4(*icall),
 	    x_offset, y_offset);
-	async_answer_0(iid, rc);
-}
-
-static void vs_suspend(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void vs_suspend(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	errno_t rc = vs->ops.suspend(vs);
-	async_answer_0(iid, rc);
-}
-
-static void vs_wakeup(visualizer_t *vs, cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void vs_wakeup(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	errno_t rc = vs->ops.wakeup(vs);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
 void graph_visualizer_connection(visualizer_t *vs,
-    cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+    cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ipc_call_t call;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 
 	/* Claim the visualizer. */
 	if (!cas(&vs->ref_cnt, 0, 1)) {
-		async_answer_0(iid, ELIMIT);
+		async_answer_0(icall_handle, ELIMIT);
 		return;
 	}
 
 	/* Accept the connection. */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	/* Establish callback session. */
-	callid = async_get_call(&call);
+	chandle = async_get_call(&call);
 	vs->notif_sess = async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
 	if (vs->notif_sess != NULL)
-		async_answer_0(callid, EOK);
+		async_answer_0(chandle, EOK);
 	else
-		async_answer_0(callid, ELIMIT);
+		async_answer_0(chandle, ELIMIT);
 
 	/* Enter command loop. */
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
@@ -525,35 +525,35 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case VISUALIZER_CLAIM:
-			vs_claim(vs, callid, &call);
+			vs_claim(vs, chandle, &call);
 			break;
 		case VISUALIZER_YIELD:
-			vs_yield(vs, callid, &call);
+			vs_yield(vs, chandle, &call);
 			goto terminate;
 		case VISUALIZER_ENUMERATE_MODES:
-			vs_enumerate_modes(vs, callid, &call);
+			vs_enumerate_modes(vs, chandle, &call);
 			break;
 		case VISUALIZER_GET_DEFAULT_MODE:
-			vs_get_default_mode(vs, callid, &call);
+			vs_get_default_mode(vs, chandle, &call);
 			break;
 		case VISUALIZER_GET_CURRENT_MODE:
-			vs_get_current_mode(vs, callid, &call);
+			vs_get_current_mode(vs, chandle, &call);
 			break;
 		case VISUALIZER_GET_MODE:
-			vs_get_mode(vs, callid, &call);
+			vs_get_mode(vs, chandle, &call);
 			break;
 		case VISUALIZER_SET_MODE:
-			vs_set_mode(vs, callid, &call);
+			vs_set_mode(vs, chandle, &call);
 			break;
 		case VISUALIZER_UPDATE_DAMAGED_REGION:
-			vs_update_damaged_region(vs, callid, &call);
+			vs_update_damaged_region(vs, chandle, &call);
 			break;
 		case VISUALIZER_SUSPEND:
-			vs_suspend(vs, callid, &call);
+			vs_suspend(vs, chandle, &call);
 			break;
 		case VISUALIZER_WAKE_UP:
-			vs_wakeup(vs, callid, &call);
+			vs_wakeup(vs, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			goto terminate;
 		}
@@ -567,21 +567,21 @@
 
 void graph_renderer_connection(renderer_t *rnd,
-    cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+    cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	// TODO
 
 	ipc_call_t call;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 
 	/* Accept the connection. */
 	atomic_inc(&rnd->ref_cnt);
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	/* Enter command loop. */
 	while (true) {
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
@@ -589,5 +589,5 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			goto terminate;
 		}
@@ -598,5 +598,5 @@
 }
 
-void graph_client_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void graph_client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Find the visualizer or renderer with the given service ID. */
@@ -605,9 +605,9 @@
 
 	if (vs != NULL)
-		graph_visualizer_connection(vs, iid, icall, arg);
+		graph_visualizer_connection(vs, icall_handle, icall, arg);
 	else if (rnd != NULL)
-		graph_renderer_connection(rnd, iid, icall, arg);
+		graph_renderer_connection(rnd, icall_handle, icall, arg);
 	else
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 }
 
Index: uspace/lib/gui/terminal.c
===================================================================
--- uspace/lib/gui/terminal.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/gui/terminal.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -677,5 +677,5 @@
 }
 
-static void term_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void term_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	terminal_t *term = NULL;
@@ -689,5 +689,5 @@
 
 	if (term == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -696,5 +696,5 @@
 		chargrid_set_cursor_visibility(term->frontbuf, true);
 
-	con_conn(iid, icall, &term->srvs);
+	con_conn(icall_handle, icall, &term->srvs);
 }
 
Index: uspace/lib/hound/include/hound/protocol.h
===================================================================
--- uspace/lib/hound/include/hound/protocol.h	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/hound/include/hound/protocol.h	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -127,5 +127,5 @@
 void hound_service_set_server_iface(const hound_server_iface_t *iface);
 
-void hound_connection_handler(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+void hound_connection_handler(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 #endif
Index: uspace/lib/hound/src/protocol.c
===================================================================
--- uspace/lib/hound/src/protocol.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/hound/src/protocol.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -384,5 +384,5 @@
  * @param arg (unused)
  */
-void hound_connection_handler(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void hound_connection_handler(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	hound_context_id_t id;
@@ -394,7 +394,7 @@
 	/* Accept connection if there is a valid iface*/
 	if (server_iface) {
-		async_answer_0(iid, EOK);
+		async_answer_0(icall_handle, EOK);
 	} else {
-		async_answer_0(iid, ENOTSUP);
+		async_answer_0(icall_handle, ENOTSUP);
 		return;
 	}
@@ -402,10 +402,10 @@
 	while (1) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		switch (IPC_GET_IMETHOD(call)) {
 		case IPC_M_HOUND_CONTEXT_REGISTER:
 			/* check interface functions */
 			if (!server_iface || !server_iface->add_context) {
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				break;
 			}
@@ -416,5 +416,5 @@
 			ret = async_data_write_accept(&name, true, 0, 0, 0, 0);
 			if (ret != EOK) {
-				async_answer_0(callid, ret);
+				async_answer_0(chandle, ret);
 				break;
 			}
@@ -426,7 +426,7 @@
 			free(name);
 			if (ret != EOK) {
-				async_answer_0(callid, ret);
+				async_answer_0(chandle, ret);
 			} else {
-				async_answer_1(callid, EOK, CAP_HANDLE_RAW(id));
+				async_answer_1(chandle, EOK, CAP_HANDLE_RAW(id));
 			}
 			break;
@@ -434,5 +434,5 @@
 			/* check interface functions */
 			if (!server_iface || !server_iface->rem_context) {
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				break;
 			}
@@ -442,10 +442,10 @@
 			ret = server_iface->rem_context(server_iface->server,
 			    id);
-			async_answer_0(callid, ret);
+			async_answer_0(chandle, ret);
 			break;
 		case IPC_M_HOUND_GET_LIST:
 			/* check interface functions */
 			if (!server_iface || !server_iface->get_list) {
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				break;
 			}
@@ -475,5 +475,5 @@
 			if (count && !sizes)
 				ret = ENOMEM;
-			async_answer_1(callid, ret, count);
+			async_answer_1(chandle, ret, count);
 
 			/* We are done */
@@ -509,5 +509,5 @@
 			/* check interface functions */
 			if (!server_iface || !server_iface->connect) {
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				break;
 			}
@@ -529,10 +529,10 @@
 			free(source);
 			free(sink);
-			async_answer_0(callid, ret);
+			async_answer_0(chandle, ret);
 			break;
 		case IPC_M_HOUND_DISCONNECT:
 			/* check interface functions */
 			if (!server_iface || !server_iface->disconnect) {
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				break;
 			}
@@ -553,5 +553,5 @@
 			free(source);
 			free(sink);
-			async_answer_0(callid, ret);
+			async_answer_0(chandle, ret);
 			break;
 		case IPC_M_HOUND_STREAM_ENTER:
@@ -560,5 +560,5 @@
 			    || !server_iface->add_stream
 			    || !server_iface->rem_stream) {
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				break;
 			}
@@ -579,5 +579,5 @@
 			    id, flags, f, bsize, &stream);
 			if (ret != EOK) {
-				async_answer_0(callid, ret);
+				async_answer_0(chandle, ret);
 				break;
 			}
@@ -586,5 +586,5 @@
 			if (rec) {
 				if(server_iface->stream_data_read) {
-					async_answer_0(callid, EOK);
+					async_answer_0(chandle, EOK);
 					/* start answering read calls */
 					hound_server_write_data(stream);
@@ -592,9 +592,9 @@
 					    server_iface->server, stream);
 				} else {
-					async_answer_0(callid, ENOTSUP);
+					async_answer_0(chandle, ENOTSUP);
 				}
 			} else {
 				if (server_iface->stream_data_write) {
-					async_answer_0(callid, EOK);
+					async_answer_0(chandle, EOK);
 					/* accept write calls */
 					hound_server_read_data(stream);
@@ -602,5 +602,5 @@
 					    server_iface->server, stream);
 				} else {
-					async_answer_0(callid, ENOTSUP);
+					async_answer_0(chandle, ENOTSUP);
 				}
 			}
@@ -609,8 +609,8 @@
 		case IPC_M_HOUND_STREAM_DRAIN:
 			/* Stream exit/drain is only allowed in stream context*/
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			return;
 		}
@@ -624,10 +624,10 @@
 static void hound_server_read_data(void *stream)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	size_t size = 0;
 	errno_t ret_answer = EOK;
 	/* accept data write or drain */
-	while (async_data_write_receive_call(&callid, &call, &size)
+	while (async_data_write_receive_call(&chandle, &call, &size)
 	    || (IPC_GET_IMETHOD(call) == IPC_M_HOUND_STREAM_DRAIN)) {
 		/* check drain first */
@@ -636,5 +636,5 @@
 			if (server_iface->drain_stream)
 				ret = server_iface->drain_stream(stream);
-			async_answer_0(callid, ret);
+			async_answer_0(chandle, ret);
 			continue;
 		}
@@ -642,5 +642,5 @@
 		/* there was an error last time */
 		if (ret_answer != EOK) {
-			async_answer_0(callid, ret_answer);
+			async_answer_0(chandle, ret_answer);
 			continue;
 		}
@@ -648,8 +648,8 @@
 		char *buffer = malloc(size);
 		if (!buffer) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			continue;
 		}
-		const errno_t ret = async_data_write_finalize(callid, buffer, size);
+		const errno_t ret = async_data_write_finalize(chandle, buffer, size);
 		if (ret == EOK) {
 			/* push data to stream */
@@ -661,5 +661,5 @@
 	    ? EOK : EINVAL;
 
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
@@ -671,10 +671,10 @@
 {
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	size_t size = 0;
 	errno_t ret_answer = EOK;
 	/* accept data read and drain */
-	while (async_data_read_receive_call(&callid, &call, &size)
+	while (async_data_read_receive_call(&chandle, &call, &size)
 	    || (IPC_GET_IMETHOD(call) == IPC_M_HOUND_STREAM_DRAIN)) {
 		/* drain does not make much sense but it is allowed */
@@ -683,15 +683,15 @@
 			if (server_iface->drain_stream)
 				ret = server_iface->drain_stream(stream);
-			async_answer_0(callid, ret);
+			async_answer_0(chandle, ret);
 			continue;
 		}
 		/* there was an error last time */
 		if (ret_answer != EOK) {
-			async_answer_0(callid, ret_answer);
+			async_answer_0(chandle, ret_answer);
 			continue;
 		}
 		char *buffer = malloc(size);
 		if (!buffer) {
-			async_answer_0(callid, ENOMEM);
+			async_answer_0(chandle, ENOMEM);
 			continue;
 		}
@@ -699,5 +699,5 @@
 		if (ret == EOK) {
 			ret_answer =
-			    async_data_read_finalize(callid, buffer, size);
+			    async_data_read_finalize(chandle, buffer, size);
 		}
 	}
@@ -705,5 +705,5 @@
 	    ? EOK : EINVAL;
 
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
Index: uspace/lib/nic/include/nic_impl.h
===================================================================
--- uspace/lib/nic/include/nic_impl.h	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/nic/include/nic_impl.h	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -82,5 +82,5 @@
 
 extern void nic_default_handler_impl(ddf_fun_t *dev_fun,
-    cap_call_handle_t callid, ipc_call_t *call);
+    cap_call_handle_t chandle, ipc_call_t *call);
 extern errno_t nic_open_impl(ddf_fun_t *fun);
 extern void nic_close_impl(ddf_fun_t *fun);
Index: uspace/lib/nic/src/nic_impl.c
===================================================================
--- uspace/lib/nic/src/nic_impl.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/nic/src/nic_impl.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -805,11 +805,11 @@
  *
  * @param fun		The DDF function where the method should be called.
- * @param callid	IPC call identifier
+ * @param chandle	IPC call identifier
  * @param call		IPC call data
  */
-void nic_default_handler_impl(ddf_fun_t *fun, cap_call_handle_t callid,
+void nic_default_handler_impl(ddf_fun_t *fun, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
-	async_answer_0(callid, ENOTSUP);
+	async_answer_0(chandle, ENOTSUP);
 }
 
Index: uspace/lib/usbhost/include/usb/host/ddf_helpers.h
===================================================================
--- uspace/lib/usbhost/include/usb/host/ddf_helpers.h	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/usbhost/include/usb/host/ddf_helpers.h	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -58,5 +58,5 @@
 errno_t hcd_ddf_get_registers(hc_device_t *hcd, hw_res_list_parsed_t *hw_res);
 
-void hcd_ddf_gen_irq_handler(cap_call_handle_t iid, ipc_call_t *call, ddf_dev_t *dev);
+void hcd_ddf_gen_irq_handler(cap_call_handle_t icall_handle, ipc_call_t *call, ddf_dev_t *dev);
 
 #endif
Index: uspace/lib/usbvirt/src/device.c
===================================================================
--- uspace/lib/usbvirt/src/device.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/usbvirt/src/device.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -54,22 +54,22 @@
  * @param arg   Local argument
  */
-static void callback_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void callback_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	assert(DEV != NULL);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
-		cap_call_handle_t callid;
+		cap_call_handle_t chandle;
 		ipc_call_t call;
 
-		callid = async_get_call(&call);
-		bool processed = usbvirt_ipc_handle_call(DEV, callid, &call);
+		chandle = async_get_call(&call);
+		bool processed = usbvirt_ipc_handle_call(DEV, chandle, &call);
 		if (!processed) {
 			if (!IPC_GET_IMETHOD(call)) {
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 				return;
 			} else
-				async_answer_0(callid, EINVAL);
+				async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/lib/usbvirt/src/ipc_dev.c
===================================================================
--- uspace/lib/usbvirt/src/ipc_dev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/lib/usbvirt/src/ipc_dev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -49,16 +49,16 @@
  */
 static void ipc_get_name(usbvirt_device_t *dev,
-    cap_call_handle_t iid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	if (dev->name == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 	}
 
 	size_t size = str_size(dev->name);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t accepted_size;
-	if (!async_data_read_receive(&callid, &accepted_size)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&chandle, &accepted_size)) {
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -67,7 +67,7 @@
 		accepted_size = size;
 	}
-	async_data_read_finalize(callid, dev->name, accepted_size);
-
-	async_answer_1(iid, EOK, accepted_size);
+	async_data_read_finalize(chandle, dev->name, accepted_size);
+
+	async_answer_1(icall_handle, EOK, accepted_size);
 }
 
@@ -79,5 +79,5 @@
  */
 static void ipc_control_read(usbvirt_device_t *dev,
-    cap_call_handle_t iid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	errno_t rc;
@@ -90,11 +90,11 @@
 	    1, 1024, 0, &setup_packet_len);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EPARTY);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EPARTY);
 		free(setup_packet);
 		return;
@@ -103,5 +103,5 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		free(setup_packet);
 		return;
@@ -113,6 +113,6 @@
 
 	if (rc != EOK) {
-		async_answer_0(data_callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(data_chandle, rc);
+		async_answer_0(icall_handle, rc);
 		free(setup_packet);
 		free(buffer);
@@ -120,6 +120,6 @@
 	}
 
-	async_data_read_finalize(data_callid, buffer, actual_len);
-	async_answer_0(iid, EOK);
+	async_data_read_finalize(data_chandle, buffer, actual_len);
+	async_answer_0(icall_handle, EOK);
 
 	free(setup_packet);
@@ -134,5 +134,5 @@
  */
 static void ipc_control_write(usbvirt_device_t *dev,
-    cap_call_handle_t iid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	size_t data_buffer_len = IPC_GET_ARG1(*icall);
@@ -146,5 +146,5 @@
 	    1, 0, 0, &setup_packet_len);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -154,5 +154,5 @@
 		    1, 0, 0, &data_buffer_len);
 		if (rc != EOK) {
-			async_answer_0(iid, rc);
+			async_answer_0(icall_handle, rc);
 			free(setup_packet);
 			return;
@@ -163,5 +163,5 @@
 	    data_buffer, data_buffer_len);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 
 	free(setup_packet);
@@ -179,5 +179,5 @@
 static void ipc_data_in(usbvirt_device_t *dev,
     usb_transfer_type_t transfer_type,
-    cap_call_handle_t iid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	usb_endpoint_t endpoint = IPC_GET_ARG1(*icall);
@@ -186,7 +186,7 @@
 
 	size_t data_len = 0;
-	cap_call_handle_t data_callid;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EPARTY);
+	cap_call_handle_t data_chandle;
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EPARTY);
 		return;
 	}
@@ -194,5 +194,5 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -203,12 +203,12 @@
 
 	if (rc != EOK) {
-		async_answer_0(data_callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(data_chandle, rc);
+		async_answer_0(icall_handle, rc);
 		free(buffer);
 		return;
 	}
 
-	async_data_read_finalize(data_callid, buffer, actual_len);
-	async_answer_0(iid, EOK);
+	async_data_read_finalize(data_chandle, buffer, actual_len);
+	async_answer_0(icall_handle, EOK);
 
 	free(buffer);
@@ -223,5 +223,5 @@
 static void ipc_data_out(usbvirt_device_t *dev,
     usb_transfer_type_t transfer_type,
-    cap_call_handle_t iid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	usb_endpoint_t endpoint = IPC_GET_ARG1(*icall);
@@ -233,5 +233,5 @@
 	    1, 0, 0, &data_buffer_size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -240,5 +240,5 @@
 	    data_buffer, data_buffer_size);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 
 	free(data_buffer);
@@ -248,38 +248,38 @@
  *
  * @param dev Target USB device.
- * @param callid Caller id.
+ * @param chandle Caller id.
  * @param call Incoming call.
  * @return Whether the call was handled.
  */
 bool usbvirt_ipc_handle_call(usbvirt_device_t *dev,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	switch (IPC_GET_IMETHOD(*call)) {
 	case IPC_M_USBVIRT_GET_NAME:
-		ipc_get_name(dev, callid, call);
+		ipc_get_name(dev, chandle, call);
 		break;
 
 	case IPC_M_USBVIRT_CONTROL_READ:
-		ipc_control_read(dev, callid, call);
+		ipc_control_read(dev, chandle, call);
 		break;
 
 	case IPC_M_USBVIRT_CONTROL_WRITE:
-		ipc_control_write(dev, callid, call);
+		ipc_control_write(dev, chandle, call);
 		break;
 
 	case IPC_M_USBVIRT_INTERRUPT_IN:
-		ipc_data_in(dev, USB_TRANSFER_INTERRUPT, callid, call);
+		ipc_data_in(dev, USB_TRANSFER_INTERRUPT, chandle, call);
 		break;
 
 	case IPC_M_USBVIRT_BULK_IN:
-		ipc_data_in(dev, USB_TRANSFER_BULK, callid, call);
+		ipc_data_in(dev, USB_TRANSFER_BULK, chandle, call);
 		break;
 
 	case IPC_M_USBVIRT_INTERRUPT_OUT:
-		ipc_data_out(dev, USB_TRANSFER_INTERRUPT, callid, call);
+		ipc_data_out(dev, USB_TRANSFER_INTERRUPT, chandle, call);
 		break;
 
 	case IPC_M_USBVIRT_BULK_OUT:
-		ipc_data_out(dev, USB_TRANSFER_BULK, callid, call);
+		ipc_data_out(dev, USB_TRANSFER_BULK, chandle, call);
 		break;
 
Index: uspace/srv/audio/hound/audio_device.c
===================================================================
--- uspace/srv/audio/hound/audio_device.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/audio/hound/audio_device.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -53,5 +53,5 @@
 static errno_t device_sink_connection_callback(audio_sink_t *sink, bool new);
 static errno_t device_source_connection_callback(audio_source_t *source, bool new);
-static void device_event_callback(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void device_event_callback(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 static errno_t device_check_format(audio_sink_t* sink);
 static errno_t get_buffer(audio_device_t *dev);
@@ -261,5 +261,5 @@
  * @param arg (unused)
  */
-static void device_event_callback(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void device_event_callback(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	struct timeval time1;
@@ -267,11 +267,11 @@
 
 	/* Answer initial request */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 	audio_device_t *dev = arg;
 	assert(dev);
 	while (1) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
-		async_answer_0(callid, EOK);
+		cap_call_handle_t chandle = async_get_call(&call);
+		async_answer_0(chandle, EOK);
 		switch(IPC_GET_IMETHOD(call)) {
 		case PCM_EVENT_FRAMES_PLAYED:
Index: uspace/srv/bd/file_bd/file_bd.c
===================================================================
--- uspace/srv/bd/file_bd/file_bd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/bd/file_bd/file_bd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -68,5 +68,5 @@
 static void print_usage(void);
 static errno_t file_bd_init(const char *fname);
-static void file_bd_connection(cap_call_handle_t iid, ipc_call_t *icall, void *);
+static void file_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *);
 
 static errno_t file_bd_open(bd_srvs_t *, bd_srv_t *);
@@ -201,7 +201,7 @@
 }
 
-static void file_bd_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	bd_conn(iid, icall, &bd_srvs);
+static void file_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	bd_conn(icall_handle, icall, &bd_srvs);
 }
 
Index: uspace/srv/bd/rd/rd.c
===================================================================
--- uspace/srv/bd/rd/rd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/bd/rd/rd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -94,7 +94,7 @@
 static bd_srvs_t bd_srvs;
 
-static void rd_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	bd_conn(iid, icall, &bd_srvs);
+static void rd_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	bd_conn(icall_handle, icall, &bd_srvs);
 }
 
Index: uspace/srv/bd/sata_bd/sata_bd.c
===================================================================
--- uspace/srv/bd/sata_bd/sata_bd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/bd/sata_bd/sata_bd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -167,5 +167,5 @@
 
 /** Block device connection handler. */
-static void sata_bd_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void sata_bd_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	service_id_t dsid;
@@ -182,9 +182,9 @@
 
 	if (disk_id < 0) {
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
-	bd_conn(iid, icall, &disk[disk_id].bds);
+	bd_conn(icall_handle, icall, &disk[disk_id].bds);
 }
 
Index: uspace/srv/bd/vbd/disk.c
===================================================================
--- uspace/srv/bd/vbd/disk.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/bd/vbd/disk.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1068,5 +1068,5 @@
 }
 
-void vbds_bd_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void vbds_bd_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	vbds_part_t *part;
@@ -1084,10 +1084,10 @@
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "vbd_bd_conn() - partition "
 		    "not found.");
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vbds_bd_conn() - call bd_conn");
-	bd_conn(iid, icall, &part->bds);
+	bd_conn(icall_handle, icall, &part->bds);
 	vbds_part_del_ref(part);
 }
Index: uspace/srv/bd/vbd/vbd.c
===================================================================
--- uspace/srv/bd/vbd/vbd.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/bd/vbd/vbd.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -87,14 +87,14 @@
 }
 
-static void vbds_get_disks_srv(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void vbds_get_disks_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -102,6 +102,6 @@
 	service_id_t *id_buf = (service_id_t *) malloc(size);
 	if (id_buf == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -110,16 +110,16 @@
 	if (rc != EOK) {
 		free(id_buf);
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, id_buf, size);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(iid, retval, act_size);
-}
-
-static void vbds_disk_info_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_1(icall_handle, retval, act_size);
+}
+
+static void vbds_disk_info_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t disk_sid;
@@ -132,34 +132,34 @@
 	rc = vbds_disk_info(disk_sid, &dinfo);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(vbd_disk_info_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &dinfo,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &dinfo,
 	    min(size, sizeof(dinfo)));
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-static void vbds_label_create_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vbds_label_create_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t disk_sid;
@@ -172,8 +172,8 @@
 	ltype = IPC_GET_ARG2(*icall);
 	rc = vbds_label_create(disk_sid, ltype);
-	async_answer_0(iid, rc);
-}
-
-static void vbds_label_delete_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void vbds_label_delete_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t disk_sid;
@@ -184,10 +184,10 @@
 	disk_sid = IPC_GET_ARG1(*icall);
 	rc = vbds_label_delete(disk_sid);
-	async_answer_0(iid, rc);
-}
-
-static void vbds_label_get_parts_srv(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	async_answer_0(icall_handle, rc);
+}
+
+static void vbds_label_get_parts_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
@@ -197,7 +197,7 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vbds_label_get_parts_srv()");
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -207,6 +207,6 @@
 	category_id_t *id_buf = (category_id_t *) malloc(size);
 	if (id_buf == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -214,16 +214,16 @@
 	rc = vbds_get_parts(sid, id_buf, size, &act_size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, id_buf, size);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(iid, retval, act_size);
-}
-
-static void vbds_part_get_info_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_1(icall_handle, retval, act_size);
+}
+
+static void vbds_part_get_info_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	vbds_part_id_t part;
@@ -236,34 +236,34 @@
 	rc = vbds_part_get_info(part, &pinfo);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(vbd_part_info_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &pinfo,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &pinfo,
 	    min(size, sizeof(pinfo)));
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-static void vbds_part_create_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vbds_part_create_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t disk_sid;
@@ -276,22 +276,22 @@
 	disk_sid = IPC_GET_ARG1(*icall);
 
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(vbd_part_spec_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &pspec, sizeof(vbd_part_spec_t));
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &pspec, sizeof(vbd_part_spec_t));
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -299,12 +299,12 @@
 	rc = vbds_part_create(disk_sid, &pspec, &part);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_1(iid, rc, (sysarg_t)part);
-}
-
-static void vbds_part_delete_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_1(icall_handle, rc, (sysarg_t)part);
+}
+
+static void vbds_part_delete_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	vbds_part_id_t part;
@@ -315,8 +315,8 @@
 	part = IPC_GET_ARG1(*icall);
 	rc = vbds_part_delete(part);
-	async_answer_0(iid, rc);
-}
-
-static void vbds_suggest_ptype_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, rc);
+}
+
+static void vbds_suggest_ptype_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t disk_sid;
@@ -332,47 +332,47 @@
 	rc = vbds_suggest_ptype(disk_sid, pcnt, &ptype);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
-	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
+	size_t size;
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(label_ptype_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &ptype, sizeof(label_ptype_t));
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-static void vbds_ctl_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &ptype, sizeof(label_ptype_t));
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vbds_ctl_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vbds_client_conn()");
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -380,37 +380,37 @@
 		switch (method) {
 		case VBD_GET_DISKS:
-			vbds_get_disks_srv(callid, &call);
+			vbds_get_disks_srv(chandle, &call);
 			break;
 		case VBD_DISK_INFO:
-			vbds_disk_info_srv(callid, &call);
+			vbds_disk_info_srv(chandle, &call);
 			break;
 		case VBD_LABEL_CREATE:
-			vbds_label_create_srv(callid, &call);
+			vbds_label_create_srv(chandle, &call);
 			break;
 		case VBD_LABEL_DELETE:
-			vbds_label_delete_srv(callid, &call);
+			vbds_label_delete_srv(chandle, &call);
 			break;
 		case VBD_LABEL_GET_PARTS:
-			vbds_label_get_parts_srv(callid, &call);
+			vbds_label_get_parts_srv(chandle, &call);
 			break;
 		case VBD_PART_GET_INFO:
-			vbds_part_get_info_srv(callid, &call);
+			vbds_part_get_info_srv(chandle, &call);
 			break;
 		case VBD_PART_CREATE:
-			vbds_part_create_srv(callid, &call);
+			vbds_part_create_srv(chandle, &call);
 			break;
 		case VBD_PART_DELETE:
-			vbds_part_delete_srv(callid, &call);
+			vbds_part_delete_srv(chandle, &call);
 			break;
 		case VBD_SUGGEST_PTYPE:
-			vbds_suggest_ptype_srv(callid, &call);
+			vbds_suggest_ptype_srv(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
 }
 
-static void vbds_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void vbds_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	service_id_t sid;
@@ -421,7 +421,7 @@
 
 	if (sid == ctl_sid)
-		vbds_ctl_conn(iid, icall, arg);
+		vbds_ctl_conn(icall_handle, icall, arg);
 	else
-		vbds_bd_conn(iid, icall, arg);
+		vbds_bd_conn(icall_handle, icall, arg);
 }
 
Index: uspace/srv/clipboard/clipboard.c
===================================================================
--- uspace/srv/clipboard/clipboard.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/clipboard/clipboard.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -95,5 +95,5 @@
 	fibril_mutex_lock(&clip_mtx);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
 
@@ -101,6 +101,6 @@
 	switch (IPC_GET_ARG1(*request)) {
 	case CLIPBOARD_TAG_DATA:
-		if (!async_data_read_receive(&callid, &size)) {
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&chandle, &size)) {
+			async_answer_0(chandle, EINVAL);
 			async_answer_0(rid, EINVAL);
 			break;
@@ -109,5 +109,5 @@
 		if (clip_tag != CLIPBOARD_TAG_DATA) {
 			/* So far we only understand binary data */
-			async_answer_0(callid, EOVERFLOW);
+			async_answer_0(chandle, EOVERFLOW);
 			async_answer_0(rid, EOVERFLOW);
 			break;
@@ -116,10 +116,10 @@
 		if (clip_size != size) {
 			/* The client expects different size of data */
-			async_answer_0(callid, EOVERFLOW);
+			async_answer_0(chandle, EOVERFLOW);
 			async_answer_0(rid, EOVERFLOW);
 			break;
 		}
 
-		errno_t retval = async_data_read_finalize(callid, clip_data, size);
+		errno_t retval = async_data_read_finalize(chandle, clip_data, size);
 		if (retval != EOK) {
 			async_answer_0(rid, retval);
@@ -152,12 +152,12 @@
 }
 
-static void clip_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -166,14 +166,14 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case CLIPBOARD_PUT_DATA:
-			clip_put_data(callid, &call);
+			clip_put_data(chandle, &call);
 			break;
 		case CLIPBOARD_GET_DATA:
-			clip_get_data(callid, &call);
+			clip_get_data(chandle, &call);
 			break;
 		case CLIPBOARD_CONTENT:
-			clip_content(callid, &call);
+			clip_content(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 		}
 	}
Index: uspace/srv/devman/client_conn.c
===================================================================
--- uspace/srv/devman/client_conn.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/devman/client_conn.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -61,5 +61,5 @@
 /** Find handle for the device instance identified by the device's path in the
  * device tree. */
-static void devman_function_get_handle(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_function_get_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	char *pathname;
@@ -68,5 +68,5 @@
 	errno_t rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -77,5 +77,5 @@
 
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -86,5 +86,5 @@
 	if (fun->state == FUN_REMOVED) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -96,9 +96,9 @@
 	fun_del_ref(fun);
 
-	async_answer_1(iid, EOK, handle);
+	async_answer_1(icall_handle, EOK, handle);
 }
 
 /** Get device match ID. */
-static void devman_fun_get_match_id(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_get_match_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -108,12 +108,12 @@
 	fun_node_t *fun = find_fun_node(&device_tree, handle);
 	if (fun == NULL) {
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t data_len;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EINVAL);
 		fun_del_ref(fun);
 		return;
@@ -122,6 +122,6 @@
 	buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		fun_del_ref(fun);
 		return;
@@ -145,6 +145,6 @@
 	}
 
-	async_data_read_finalize(data_callid, mid->id, sent_length);
-	async_answer_1(iid, EOK, mid->score);
+	async_data_read_finalize(data_chandle, mid->id, sent_length);
+	async_answer_1(icall_handle, EOK, mid->score);
 
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -157,11 +157,11 @@
 	free(buffer);
 
-	async_answer_0(data_callid, ENOENT);
-	async_answer_0(iid, ENOENT);
+	async_answer_0(data_chandle, ENOENT);
+	async_answer_0(icall_handle, ENOENT);
 	fun_del_ref(fun);
 }
 
 /** Get device name. */
-static void devman_fun_get_name(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -169,12 +169,12 @@
 	fun_node_t *fun = find_fun_node(&device_tree, handle);
 	if (fun == NULL) {
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t data_len;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EINVAL);
 		fun_del_ref(fun);
 		return;
@@ -183,6 +183,6 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		fun_del_ref(fun);
 		return;
@@ -196,6 +196,6 @@
 		free(buffer);
 
-		async_answer_0(data_callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(data_chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		fun_del_ref(fun);
 		return;
@@ -207,6 +207,6 @@
 	}
 
-	async_data_read_finalize(data_callid, fun->name, sent_length);
-	async_answer_0(iid, EOK);
+	async_data_read_finalize(data_chandle, fun->name, sent_length);
+	async_answer_0(icall_handle, EOK);
 
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -216,5 +216,5 @@
 
 /** Get function driver name. */
-static void devman_fun_get_driver_name(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_get_driver_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -222,12 +222,12 @@
 	fun_node_t *fun = find_fun_node(&device_tree, handle);
 	if (fun == NULL) {
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t data_len;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EINVAL);
 		fun_del_ref(fun);
 		return;
@@ -236,6 +236,6 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		fun_del_ref(fun);
 		return;
@@ -249,6 +249,6 @@
 		free(buffer);
 
-		async_answer_0(data_callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(data_chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		fun_del_ref(fun);
 		return;
@@ -260,6 +260,6 @@
 		free(buffer);
 
-		async_answer_0(data_callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		fun_del_ref(fun);
 		return;
@@ -271,7 +271,7 @@
 	}
 
-	async_data_read_finalize(data_callid, fun->child->drv->name,
+	async_data_read_finalize(data_chandle, fun->child->drv->name,
 	    sent_length);
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -281,5 +281,5 @@
 
 /** Get device path. */
-static void devman_fun_get_path(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_get_path(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -287,12 +287,12 @@
 	fun_node_t *fun = find_fun_node(&device_tree, handle);
 	if (fun == NULL) {
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t data_len;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EINVAL);
 		fun_del_ref(fun);
 		return;
@@ -301,6 +301,6 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		fun_del_ref(fun);
 		return;
@@ -314,6 +314,6 @@
 		free(buffer);
 
-		async_answer_0(data_callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(data_chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		fun_del_ref(fun);
 		return;
@@ -325,6 +325,6 @@
 	}
 
-	async_data_read_finalize(data_callid, fun->pathname, sent_length);
-	async_answer_0(iid, EOK);
+	async_data_read_finalize(data_chandle, fun->pathname, sent_length);
+	async_answer_0(icall_handle, EOK);
 
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -334,5 +334,5 @@
 
 /** Get handle for parent function of a device. */
-static void devman_dev_get_parent(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_dev_get_parent(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	dev_node_t *dev;
@@ -343,5 +343,5 @@
 	if (dev == NULL || dev->state == DEVICE_REMOVED) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -349,23 +349,23 @@
 	if (dev->pfun == NULL) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
-		return;
-	}
-
-	async_answer_1(iid, EOK, dev->pfun->handle);
-
-	fibril_rwlock_read_unlock(&device_tree.rwlock);
-}
-
-static void devman_dev_get_functions(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+		async_answer_0(icall_handle, ENOENT);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, dev->pfun->handle);
+
+	fibril_rwlock_read_unlock(&device_tree.rwlock);
+}
+
+static void devman_dev_get_functions(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -377,6 +377,6 @@
 	if (dev == NULL || dev->state == DEVICE_REMOVED) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -385,6 +385,6 @@
 	if (hdl_buf == NULL) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -393,19 +393,19 @@
 	if (rc != EOK) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	fibril_rwlock_read_unlock(&device_tree.rwlock);
-
-	errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	fibril_rwlock_read_unlock(&device_tree.rwlock);
+
+	errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
 	free(hdl_buf);
 
-	async_answer_1(iid, retval, act_size);
+	async_answer_1(icall_handle, retval, act_size);
 }
 
 /** Get handle for child device of a function. */
-static void devman_fun_get_child(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_get_child(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fun_node_t *fun;
@@ -416,5 +416,5 @@
 	if (fun == NULL || fun->state == FUN_REMOVED) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -422,9 +422,9 @@
 	if (fun->child == NULL) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
-		return;
-	}
-
-	async_answer_1(iid, EOK, fun->child->handle);
+		async_answer_0(icall_handle, ENOENT);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, fun->child->handle);
 
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -437,5 +437,5 @@
  * of this function is linked to state of another function somehow).
  */
-static void devman_fun_online(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fun_node_t *fun;
@@ -444,5 +444,5 @@
 	fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -451,5 +451,5 @@
 	fun_del_ref(fun);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -462,5 +462,5 @@
  * function somehow).
  */
-static void devman_fun_offline(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fun_node_t *fun;
@@ -469,5 +469,5 @@
 	fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -476,9 +476,9 @@
 	fun_del_ref(fun);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
 /** Find handle for the function instance identified by its service ID. */
-static void devman_fun_sid_to_handle(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_fun_sid_to_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fun_node_t *fun;
@@ -487,5 +487,5 @@
 
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -496,9 +496,9 @@
 	if (fun->state == FUN_REMOVED) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
-		return;
-	}
-
-	async_answer_1(iid, EOK, fun->handle);
+		async_answer_0(icall_handle, ENOENT);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, fun->handle);
 	fibril_rwlock_read_unlock(&device_tree.rwlock);
 	fun_del_ref(fun);
@@ -506,13 +506,13 @@
 
 /** Get list of all registered drivers. */
-static void devman_get_drivers(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void devman_get_drivers(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -520,6 +520,6 @@
 	devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
 	if (hdl_buf == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -527,24 +527,24 @@
 	rc = driver_get_list(&drivers_list, hdl_buf, size, &act_size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
 	free(hdl_buf);
 
-	async_answer_1(iid, retval, act_size);
-}
-
-static void devman_driver_get_devices(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	async_answer_1(icall_handle, retval, act_size);
+}
+
+static void devman_driver_get_devices(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -552,6 +552,6 @@
 	driver_t *drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
 	if (drv == NULL) {
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -559,6 +559,6 @@
 	devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
 	if (hdl_buf == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -567,18 +567,18 @@
 	if (rc != EOK) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
 	free(hdl_buf);
 
-	async_answer_1(iid, retval, act_size);
+	async_answer_1(icall_handle, retval, act_size);
 }
 
 
 /** Find driver by name. */
-static void devman_driver_get_handle(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_driver_get_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	char *drvname;
@@ -586,5 +586,5 @@
 	errno_t rc = async_data_write_accept((void **) &drvname, true, 0, 0, 0, 0);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -595,13 +595,13 @@
 
 	if (driver == NULL) {
-		async_answer_0(iid, ENOENT);
-		return;
-	}
-
-	async_answer_1(iid, EOK, driver->handle);
+		async_answer_0(icall_handle, ENOENT);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, driver->handle);
 }
 
 /** Get driver match ID. */
-static void devman_driver_get_match_id(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_driver_get_match_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -610,12 +610,12 @@
 	driver_t *drv = driver_find(&drivers_list, handle);
 	if (drv == NULL) {
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t data_len;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -623,6 +623,6 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -633,6 +633,6 @@
 		fibril_mutex_unlock(&drv->driver_mutex);
 		free(buffer);
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -645,6 +645,6 @@
 	}
 
-	async_data_read_finalize(data_callid, mid->id, sent_length);
-	async_answer_1(iid, EOK, mid->score);
+	async_data_read_finalize(data_chandle, mid->id, sent_length);
+	async_answer_1(icall_handle, EOK, mid->score);
 
 	fibril_mutex_unlock(&drv->driver_mutex);
@@ -654,5 +654,5 @@
 
 /** Get driver name. */
-static void devman_driver_get_name(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_driver_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -660,12 +660,12 @@
 	driver_t *drv = driver_find(&drivers_list, handle);
 	if (drv == NULL) {
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	cap_call_handle_t data_callid;
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	cap_call_handle_t data_chandle;
 	size_t data_len;
-	if (!async_data_read_receive(&data_callid, &data_len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&data_chandle, &data_len)) {
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -673,6 +673,6 @@
 	void *buffer = malloc(data_len);
 	if (buffer == NULL) {
-		async_answer_0(data_callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(data_chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -685,6 +685,6 @@
 	}
 
-	async_data_read_finalize(data_callid, drv->name, sent_length);
-	async_answer_0(iid, EOK);
+	async_data_read_finalize(data_chandle, drv->name, sent_length);
+	async_answer_0(icall_handle, EOK);
 
 	fibril_mutex_unlock(&drv->driver_mutex);
@@ -694,5 +694,5 @@
 
 /** Get driver state. */
-static void devman_driver_get_state(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_driver_get_state(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	driver_t *drv;
@@ -700,13 +700,13 @@
 	drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
 	if (drv == NULL) {
-		async_answer_0(iid, ENOENT);
-		return;
-	}
-
-	async_answer_1(iid, EOK, (sysarg_t) drv->state);
+		async_answer_0(icall_handle, ENOENT);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, (sysarg_t) drv->state);
 }
 
 /** Forcibly load a driver. */
-static void devman_driver_load(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_driver_load(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	driver_t *drv;
@@ -715,5 +715,5 @@
 	drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
 	if (drv == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -723,9 +723,9 @@
 	fibril_mutex_unlock(&drv->driver_mutex);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
 /** Unload a driver by user request. */
-static void devman_driver_unload(cap_call_handle_t iid, ipc_call_t *icall)
+static void devman_driver_unload(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	driver_t *drv;
@@ -734,5 +734,5 @@
 	drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
 	if (drv == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -742,16 +742,16 @@
 	fibril_mutex_unlock(&drv->driver_mutex);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
 /** Function for handling connections from a client to the device manager. */
-void devman_connection_client(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void devman_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection. */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -760,62 +760,62 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case DEVMAN_DEVICE_GET_HANDLE:
-			devman_function_get_handle(callid, &call);
+			devman_function_get_handle(chandle, &call);
 			break;
 		case DEVMAN_DEV_GET_PARENT:
-			devman_dev_get_parent(callid, &call);
+			devman_dev_get_parent(chandle, &call);
 			break;
 		case DEVMAN_DEV_GET_FUNCTIONS:
-			devman_dev_get_functions(callid, &call);
+			devman_dev_get_functions(chandle, &call);
 			break;
 		case DEVMAN_FUN_GET_CHILD:
-			devman_fun_get_child(callid, &call);
+			devman_fun_get_child(chandle, &call);
 			break;
 		case DEVMAN_FUN_GET_MATCH_ID:
-			devman_fun_get_match_id(callid, &call);
+			devman_fun_get_match_id(chandle, &call);
 			break;
 		case DEVMAN_FUN_GET_NAME:
-			devman_fun_get_name(callid, &call);
+			devman_fun_get_name(chandle, &call);
 			break;
 		case DEVMAN_FUN_GET_DRIVER_NAME:
-			devman_fun_get_driver_name(callid, &call);
+			devman_fun_get_driver_name(chandle, &call);
 			break;
 		case DEVMAN_FUN_GET_PATH:
-			devman_fun_get_path(callid, &call);
+			devman_fun_get_path(chandle, &call);
 			break;
 		case DEVMAN_FUN_ONLINE:
-			devman_fun_online(callid, &call);
+			devman_fun_online(chandle, &call);
 			break;
 		case DEVMAN_FUN_OFFLINE:
-			devman_fun_offline(callid, &call);
+			devman_fun_offline(chandle, &call);
 			break;
 		case DEVMAN_FUN_SID_TO_HANDLE:
-			devman_fun_sid_to_handle(callid, &call);
+			devman_fun_sid_to_handle(chandle, &call);
 			break;
 		case DEVMAN_GET_DRIVERS:
-			devman_get_drivers(callid, &call);
+			devman_get_drivers(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_GET_DEVICES:
-			devman_driver_get_devices(callid, &call);
+			devman_driver_get_devices(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_GET_HANDLE:
-			devman_driver_get_handle(callid, &call);
+			devman_driver_get_handle(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_GET_MATCH_ID:
-			devman_driver_get_match_id(callid, &call);
+			devman_driver_get_match_id(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_GET_NAME:
-			devman_driver_get_name(callid, &call);
+			devman_driver_get_name(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_GET_STATE:
-			devman_driver_get_state(callid, &call);
+			devman_driver_get_state(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_LOAD:
-			devman_driver_load(callid, &call);
+			devman_driver_load(chandle, &call);
 			break;
 		case DEVMAN_DRIVER_UNLOAD:
-			devman_driver_unload(callid, &call);
+			devman_driver_unload(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 		}
 	}
Index: uspace/srv/devman/drv_conn.c
===================================================================
--- uspace/srv/devman/drv_conn.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/devman/drv_conn.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -64,5 +64,5 @@
 
 /** Register running driver. */
-static driver_t *devman_driver_register(cap_call_handle_t callid, ipc_call_t *call)
+static driver_t *devman_driver_register(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	driver_t *driver = NULL;
@@ -74,5 +74,5 @@
 	errno_t rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return NULL;
 	}
@@ -87,5 +87,5 @@
 		free(drv_name);
 		drv_name = NULL;
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return NULL;
 	}
@@ -101,5 +101,5 @@
 		    driver->name);
 		fibril_mutex_unlock(&driver->driver_mutex);
-		async_answer_0(callid, EEXIST);
+		async_answer_0(chandle, EEXIST);
 		return NULL;
 	}
@@ -126,5 +126,5 @@
 	if (!driver->sess) {
 		fibril_mutex_unlock(&driver->driver_mutex);
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return NULL;
 	}
@@ -146,5 +146,5 @@
 		    "for driver `%s'.", driver->name);
 		fibril_mutex_unlock(&driver->driver_mutex);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return NULL;
 	}
@@ -153,5 +153,5 @@
 	fibril_mutex_unlock(&driver->driver_mutex);
 
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 	return driver;
 }
@@ -166,13 +166,13 @@
 {
 	match_id_t *match_id = create_match_id();
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 	errno_t rc = 0;
 
-	callid = async_get_call(&call);
+	chandle = async_get_call(&call);
 	if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
 		log_msg(LOG_DEFAULT, LVL_ERROR,
 		    "Invalid protocol when trying to receive match id.");
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		delete_match_id(match_id);
 		return EINVAL;
@@ -181,9 +181,9 @@
 	if (match_id == NULL) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id.");
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return ENOMEM;
 	}
 
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 
 	match_id->score = IPC_GET_ARG1(call);
@@ -230,5 +230,5 @@
  * Child devices are registered by their parent's device driver.
  */
-static void devman_add_function(cap_call_handle_t callid, ipc_call_t *call)
+static void devman_add_function(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
@@ -239,5 +239,5 @@
 	dev_node_t *pdev = find_dev_node(&device_tree, dev_handle);
 	if (pdev == NULL) {
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -250,5 +250,5 @@
 
 		dev_del_ref(pdev);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
@@ -258,5 +258,5 @@
 	if (rc != EOK) {
 		dev_del_ref(pdev);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -268,5 +268,5 @@
 		fibril_rwlock_write_unlock(&tree->rwlock);
 		dev_del_ref(pdev);
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -278,5 +278,5 @@
 		fibril_rwlock_write_unlock(&tree->rwlock);
 		dev_del_ref(pdev);
-		async_answer_0(callid, EEXIST);
+		async_answer_0(chandle, EEXIST);
 		printf(NAME ": Warning, driver tried to register `%s' twice.\n",
 		    fun_name);
@@ -303,5 +303,5 @@
 		fun_del_ref(fun);
 		delete_fun_node(fun);
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -317,5 +317,5 @@
 		fun_busy_unlock(fun);
 		fun_del_ref(fun);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -325,8 +325,8 @@
 
 	/* Return device handle to parent's driver. */
-	async_answer_1(callid, EOK, fun->handle);
-}
-
-static void devman_add_function_to_cat(cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_1(chandle, EOK, fun->handle);
+}
+
+static void devman_add_function_to_cat(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	devman_handle_t handle = IPC_GET_ARG1(*call);
@@ -339,5 +339,5 @@
 	    0, 0, 0, 0);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -345,5 +345,5 @@
 	fun_node_t *fun = find_fun_node(&device_tree, handle);
 	if (fun == NULL) {
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -354,5 +354,5 @@
 	if (fun->state == FUN_REMOVED) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -371,5 +371,5 @@
 	fun_del_ref(fun);
 
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
@@ -377,5 +377,5 @@
  *
  */
-static void devman_drv_fun_online(cap_call_handle_t iid, ipc_call_t *icall,
+static void devman_drv_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall,
     driver_t *drv)
 {
@@ -387,5 +387,5 @@
 	fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -398,5 +398,5 @@
 		fun_busy_unlock(fun);
 		fun_del_ref(fun);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -407,5 +407,5 @@
 		fun_busy_unlock(fun);
 		fun_del_ref(fun);
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -414,5 +414,5 @@
 	fun_del_ref(fun);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -421,5 +421,5 @@
  *
  */
-static void devman_drv_fun_offline(cap_call_handle_t iid, ipc_call_t *icall,
+static void devman_drv_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall,
     driver_t *drv)
 {
@@ -429,5 +429,5 @@
 	fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
 	if (fun == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -439,5 +439,5 @@
 		fun_busy_unlock(fun);
 		fun_del_ref(fun);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -448,5 +448,5 @@
 		fun_busy_unlock(fun);
 		fun_del_ref(fun);
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -454,9 +454,9 @@
 	fun_busy_unlock(fun);
 	fun_del_ref(fun);
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
 /** Remove function. */
-static void devman_remove_function(cap_call_handle_t callid, ipc_call_t *call)
+static void devman_remove_function(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	devman_handle_t fun_handle = IPC_GET_ARG1(*call);
@@ -466,5 +466,5 @@
 	fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
 	if (fun == NULL) {
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -481,5 +481,5 @@
 		fun_busy_unlock(fun);
 		fun_del_ref(fun);
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -523,5 +523,5 @@
 				fun_busy_unlock(fun);
 				fun_del_ref(fun);
-				async_answer_0(callid, gone_rc);
+				async_answer_0(chandle, gone_rc);
 				return;
 			}
@@ -551,5 +551,5 @@
 				fun_busy_unlock(fun);
 				fun_del_ref(fun);
-				async_answer_0(callid, EIO);
+				async_answer_0(chandle, EIO);
 				return;
 			}
@@ -567,5 +567,5 @@
 
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded.");
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 }
 
@@ -586,5 +586,5 @@
 
 /** Function for handling connections from a driver to the device manager. */
-void devman_connection_driver(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void devman_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	client_t *client;
@@ -592,5 +592,5 @@
 
 	/* Accept the connection. */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	client = async_get_client_data();
@@ -602,5 +602,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -613,5 +613,5 @@
 			if (driver == NULL) {
 				/* First call must be to DEVMAN_DRIVER_REGISTER */
-				async_answer_0(callid, ENOTSUP);
+				async_answer_0(chandle, ENOTSUP);
 				continue;
 			}
@@ -623,27 +623,27 @@
 			if (client->driver != NULL) {
 				fibril_mutex_unlock(&client->mutex);
-				async_answer_0(callid, EINVAL);
+				async_answer_0(chandle, EINVAL);
 				continue;
 			}
-			client->driver = devman_driver_register(callid, &call);
+			client->driver = devman_driver_register(chandle, &call);
 			fibril_mutex_unlock(&client->mutex);
 			break;
 		case DEVMAN_ADD_FUNCTION:
-			devman_add_function(callid, &call);
+			devman_add_function(chandle, &call);
 			break;
 		case DEVMAN_ADD_DEVICE_TO_CATEGORY:
-			devman_add_function_to_cat(callid, &call);
+			devman_add_function_to_cat(chandle, &call);
 			break;
 		case DEVMAN_DRV_FUN_ONLINE:
-			devman_drv_fun_online(callid, &call, driver);
+			devman_drv_fun_online(chandle, &call, driver);
 			break;
 		case DEVMAN_DRV_FUN_OFFLINE:
-			devman_drv_fun_offline(callid, &call, driver);
+			devman_drv_fun_offline(chandle, &call, driver);
 			break;
 		case DEVMAN_REMOVE_FUNCTION:
-			devman_remove_function(callid, &call);
+			devman_remove_function(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/srv/devman/main.c
===================================================================
--- uspace/srv/devman/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/devman/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -66,5 +66,5 @@
 dev_tree_t device_tree;
 
-static void devman_connection_device(cap_call_handle_t iid, ipc_call_t *icall,
+static void devman_connection_device(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -94,5 +94,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
 		    "function with handle %" PRIun " was found.", handle);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		goto cleanup;
 	}
@@ -102,5 +102,5 @@
 		    "connect to handle %" PRIun ", refers to a device.",
 		    handle);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		goto cleanup;
 	}
@@ -116,5 +116,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - "
 		    "the device %" PRIun " is not in usable state.", handle);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		goto cleanup;
 	}
@@ -123,5 +123,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR,
 		    "Could not forward to driver `%s'.", driver->name);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		goto cleanup;
 	}
@@ -138,5 +138,5 @@
 
 	async_exch_t *exch = async_exchange_begin(driver->sess);
-	async_forward_fast(iid, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
+	async_forward_fast(icall_handle, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 
@@ -149,5 +149,5 @@
 }
 
-static void devman_connection_parent(cap_call_handle_t iid, ipc_call_t *icall,
+static void devman_connection_parent(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -177,5 +177,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
 		    "function with handle %" PRIun " was found.", handle);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		goto cleanup;
 	}
@@ -196,5 +196,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - "
 		    "the device %" PRIun " is not in usable state.", handle);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		goto cleanup;
 	}
@@ -203,5 +203,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR,
 		    "Could not forward to driver `%s'.", driver->name);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		goto cleanup;
 	}
@@ -218,5 +218,5 @@
 
 	async_exch_t *exch = async_exchange_begin(driver->sess);
-	async_forward_fast(iid, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
+	async_forward_fast(icall_handle, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 
@@ -229,5 +229,5 @@
 }
 
-static void devman_forward(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void devman_forward(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	iface_t iface = IPC_GET_ARG1(*icall);
@@ -242,5 +242,5 @@
 		    "not found.\n");
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -253,5 +253,5 @@
 
 	async_exch_t *exch = async_exchange_begin(driver->sess);
-	async_forward_fast(iid, exch, iface, handle, 0, IPC_FF_NONE);
+	async_forward_fast(icall_handle, exch, iface, handle, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 
Index: uspace/srv/fs/cdfs/cdfs_ops.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/cdfs/cdfs_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1271,8 +1271,8 @@
 	}
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -1281,5 +1281,5 @@
 		if (pos >= node->size) {
 			*rbytes = 0;
-			async_data_read_finalize(callid, NULL, 0);
+			async_data_read_finalize(chandle, NULL, 0);
 		} else {
 			cdfs_lba_t lba = pos / BLOCK_SIZE;
@@ -1293,9 +1293,9 @@
 			    BLOCK_FLAGS_NONE);
 			if (rc != EOK) {
-				async_answer_0(callid, rc);
+				async_answer_0(chandle, rc);
 				return rc;
 			}
 
-			async_data_read_finalize(callid, block->data + offset,
+			async_data_read_finalize(chandle, block->data + offset,
 			    *rbytes);
 			rc = block_put(block);
@@ -1306,5 +1306,5 @@
 		link_t *link = list_nth(&node->cs_list, pos);
 		if (link == NULL) {
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 			return ENOENT;
 		}
@@ -1314,5 +1314,5 @@
 
 		*rbytes = 1;
-		async_data_read_finalize(callid, dentry->name,
+		async_data_read_finalize(chandle, dentry->name,
 		    str_size(dentry->name) + 1);
 	}
Index: uspace/srv/fs/exfat/exfat_ops.c
===================================================================
--- uspace/srv/fs/exfat/exfat_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/exfat/exfat_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1337,9 +1337,9 @@
 	nodep = EXFAT_NODE(fn);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
-	if (!async_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&chandle, &len)) {
 		exfat_node_put(fn);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -1356,5 +1356,5 @@
 			/* reading beyond the EOF */
 			bytes = 0;
-			(void) async_data_read_finalize(callid, NULL, 0);
+			(void) async_data_read_finalize(chandle, NULL, 0);
 		} else {
 			bytes = min(len, BPS(bs) - pos % BPS(bs));
@@ -1364,8 +1364,8 @@
 			if (rc != EOK) {
 				exfat_node_put(fn);
-				async_answer_0(callid, rc);
+				async_answer_0(chandle, rc);
 				return rc;
 			}
-			(void) async_data_read_finalize(callid,
+			(void) async_data_read_finalize(chandle,
 			    b->data + pos % BPS(bs), bytes);
 			rc = block_put(b);
@@ -1377,5 +1377,5 @@
 	} else {
 		if (nodep->type != EXFAT_DIRECTORY) {
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			return ENOTSUP;
 		}
@@ -1411,5 +1411,5 @@
 err:
 		(void) exfat_node_put(fn);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 
@@ -1419,5 +1419,5 @@
 			goto err;
 		rc = exfat_node_put(fn);
-		async_answer_0(callid, rc != EOK ? rc : ENOENT);
+		async_answer_0(chandle, rc != EOK ? rc : ENOENT);
 		*rbytes = 0;
 		return rc != EOK ? rc : ENOENT;
@@ -1428,5 +1428,5 @@
 		if (rc != EOK)
 			goto err;
-		(void) async_data_read_finalize(callid, name,
+		(void) async_data_read_finalize(chandle, name,
 		    str_size(name) + 1);
 		bytes = (pos - spos) + 1;
@@ -1481,9 +1481,9 @@
 	nodep = EXFAT_NODE(fn);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
-	if (!async_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&chandle, &len)) {
 		(void) exfat_node_put(fn);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -1510,5 +1510,5 @@
 			/* could not expand node */
 			(void) exfat_node_put(fn);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
@@ -1529,9 +1529,9 @@
 	if (rc != EOK) {
 		(void) exfat_node_put(fn);
-		async_answer_0(callid, rc);
-		return rc;
-	}
-
-	(void) async_data_write_finalize(callid,
+		async_answer_0(chandle, rc);
+		return rc;
+	}
+
+	(void) async_data_write_finalize(chandle,
 	    b->data + pos % BPS(bs), bytes);
 	b->dirty = true;		/* need to sync block */
Index: uspace/srv/fs/fat/fat_ops.c
===================================================================
--- uspace/srv/fs/fat/fat_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/fat/fat_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -1226,9 +1226,9 @@
 	nodep = FAT_NODE(fn);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
-	if (!async_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&chandle, &len)) {
 		fat_node_put(fn);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -1245,5 +1245,5 @@
 			/* reading beyond the EOF */
 			bytes = 0;
-			(void) async_data_read_finalize(callid, NULL, 0);
+			(void) async_data_read_finalize(chandle, NULL, 0);
 		} else {
 			bytes = min(len, BPS(bs) - pos % BPS(bs));
@@ -1253,8 +1253,8 @@
 			if (rc != EOK) {
 				fat_node_put(fn);
-				async_answer_0(callid, rc);
+				async_answer_0(chandle, rc);
 				return rc;
 			}
-			(void) async_data_read_finalize(callid,
+			(void) async_data_read_finalize(chandle,
 			    b->data + pos % BPS(bs), bytes);
 			rc = block_put(b);
@@ -1291,5 +1291,5 @@
 err:
 		(void) fat_node_put(fn);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 
@@ -1299,5 +1299,5 @@
 			goto err;
 		rc = fat_node_put(fn);
-		async_answer_0(callid, rc != EOK ? rc : ENOENT);
+		async_answer_0(chandle, rc != EOK ? rc : ENOENT);
 		*rbytes = 0;
 		return rc != EOK ? rc : ENOENT;
@@ -1308,5 +1308,5 @@
 		if (rc != EOK)
 			goto err;
-		(void) async_data_read_finalize(callid, name,
+		(void) async_data_read_finalize(chandle, name,
 		    str_size(name) + 1);
 		bytes = (pos - spos) + 1;
@@ -1338,9 +1338,9 @@
 	nodep = FAT_NODE(fn);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
-	if (!async_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&chandle, &len)) {
 		(void) fat_node_put(fn);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -1370,5 +1370,5 @@
 		if (rc != EOK) {
 			(void) fat_node_put(fn);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
@@ -1376,8 +1376,8 @@
 		if (rc != EOK) {
 			(void) fat_node_put(fn);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
-		(void) async_data_write_finalize(callid,
+		(void) async_data_write_finalize(chandle,
 		    b->data + pos % BPS(bs), bytes);
 		b->dirty = true;		/* need to sync block */
@@ -1409,5 +1409,5 @@
 			/* could not allocate a chain of nclsts clusters */
 			(void) fat_node_put(fn);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
@@ -1417,5 +1417,5 @@
 			(void) fat_free_clusters(bs, service_id, mcl);
 			(void) fat_node_put(fn);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
@@ -1425,8 +1425,8 @@
 			(void) fat_free_clusters(bs, service_id, mcl);
 			(void) fat_node_put(fn);
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			return rc;
 		}
-		(void) async_data_write_finalize(callid,
+		(void) async_data_write_finalize(chandle,
 		    b->data + pos % BPS(bs), bytes);
 		b->dirty = true;		/* need to sync block */
Index: uspace/srv/fs/locfs/locfs_ops.c
===================================================================
--- uspace/srv/fs/locfs/locfs_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/locfs/locfs_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -478,8 +478,8 @@
 {
 	if (index == 0) {
-		cap_call_handle_t callid;
+		cap_call_handle_t chandle;
 		size_t size;
-		if (!async_data_read_receive(&callid, &size)) {
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&chandle, &size)) {
+			async_answer_0(chandle, EINVAL);
 			return EINVAL;
 		}
@@ -500,5 +500,5 @@
 
 		if (pos < count) {
-			async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
+			async_data_read_finalize(chandle, desc[pos].name, str_size(desc[pos].name) + 1);
 			free(desc);
 			*rbytes = 1;
@@ -515,5 +515,5 @@
 
 			if (pos < count) {
-				async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
+				async_data_read_finalize(chandle, desc[pos].name, str_size(desc[pos].name) + 1);
 				free(desc);
 				*rbytes = 1;
@@ -524,5 +524,5 @@
 		}
 
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return ENOENT;
 	}
@@ -532,8 +532,8 @@
 	if (type == LOC_OBJECT_NAMESPACE) {
 		/* Namespace directory */
-		cap_call_handle_t callid;
+		cap_call_handle_t chandle;
 		size_t size;
-		if (!async_data_read_receive(&callid, &size)) {
-			async_answer_0(callid, EINVAL);
+		if (!async_data_read_receive(&chandle, &size)) {
+			async_answer_0(chandle, EINVAL);
 			return EINVAL;
 		}
@@ -543,5 +543,5 @@
 
 		if (pos < count) {
-			async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
+			async_data_read_finalize(chandle, desc[pos].name, str_size(desc[pos].name) + 1);
 			free(desc);
 			*rbytes = 1;
@@ -550,5 +550,5 @@
 
 		free(desc);
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return ENOENT;
 	}
@@ -568,8 +568,8 @@
 		assert(dev->sess);
 
-		cap_call_handle_t callid;
-		if (!async_data_read_receive(&callid, NULL)) {
+		cap_call_handle_t chandle;
+		if (!async_data_read_receive(&chandle, NULL)) {
 			fibril_mutex_unlock(&services_mutex);
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return EINVAL;
 		}
@@ -583,5 +583,5 @@
 
 		/* Forward the IPC_M_DATA_READ request to the driver */
-		async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+		async_forward_fast(chandle, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
 
 		async_exchange_end(exch);
@@ -632,8 +632,8 @@
 		assert(dev->sess);
 
-		cap_call_handle_t callid;
-		if (!async_data_write_receive(&callid, NULL)) {
+		cap_call_handle_t chandle;
+		if (!async_data_write_receive(&chandle, NULL)) {
 			fibril_mutex_unlock(&services_mutex);
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return EINVAL;
 		}
@@ -647,5 +647,5 @@
 
 		/* Forward the IPC_M_DATA_WRITE request to the driver */
-		async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+		async_forward_fast(chandle, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
 
 		async_exchange_end(exch);
Index: uspace/srv/fs/mfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/mfs/mfs_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/mfs/mfs_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -837,10 +837,10 @@
 	struct mfs_ino_info *ino_i;
 	size_t len, bytes = 0;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 
 	mnode = fn->data;
 	ino_i = mnode->ino_i;
 
-	if (!async_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&chandle, &len)) {
 		rc = EINVAL;
 		goto out_error;
@@ -869,8 +869,8 @@
 
 		rc = mfs_node_put(fn);
-		async_answer_0(callid, rc != EOK ? rc : ENOENT);
+		async_answer_0(chandle, rc != EOK ? rc : ENOENT);
 		return rc;
 found:
-		async_data_read_finalize(callid, d_info.d_name,
+		async_data_read_finalize(chandle, d_info.d_name,
 		    str_size(d_info.d_name) + 1);
 		bytes = ((pos - spos) + 1);
@@ -881,5 +881,5 @@
 			/* Trying to read beyond the end of file */
 			bytes = 0;
-			(void) async_data_read_finalize(callid, NULL, 0);
+			(void) async_data_read_finalize(chandle, NULL, 0);
 			goto out_success;
 		}
@@ -903,5 +903,5 @@
 			}
 			memset(buf, 0, sizeof(sbi->block_size));
-			async_data_read_finalize(callid,
+			async_data_read_finalize(chandle,
 			    buf + pos % sbi->block_size, bytes);
 			free(buf);
@@ -913,5 +913,5 @@
 			goto out_error;
 
-		async_data_read_finalize(callid, b->data +
+		async_data_read_finalize(chandle, b->data +
 		    pos % sbi->block_size, bytes);
 
@@ -928,5 +928,5 @@
 out_error:
 	tmp = mfs_node_put(fn);
-	async_answer_0(callid, tmp != EOK ? tmp : rc);
+	async_answer_0(chandle, tmp != EOK ? tmp : rc);
 	return tmp != EOK ? tmp : rc;
 }
@@ -946,8 +946,8 @@
 		return ENOENT;
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
 
-	if (!async_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&chandle, &len)) {
 		r = EINVAL;
 		goto out_err;
@@ -992,5 +992,5 @@
 		memset(b->data, 0, sbi->block_size);
 
-	async_data_write_finalize(callid, b->data + (pos % bs), bytes);
+	async_data_write_finalize(chandle, b->data + (pos % bs), bytes);
 	b->dirty = true;
 
@@ -1012,5 +1012,5 @@
 out_err:
 	mfs_node_put(fn);
-	async_answer_0(callid, r);
+	async_answer_0(chandle, r);
 	return r;
 }
Index: uspace/srv/fs/tmpfs/tmpfs_ops.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -484,8 +484,8 @@
 	 * Receive the read request.
 	 */
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -494,5 +494,5 @@
 	if (nodep->type == TMPFS_FILE) {
 		bytes = min(nodep->size - pos, size);
-		(void) async_data_read_finalize(callid, nodep->data + pos,
+		(void) async_data_read_finalize(chandle, nodep->data + pos,
 		    bytes);
 	} else {
@@ -510,5 +510,5 @@
 
 		if (lnk == NULL) {
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 			return ENOENT;
 		}
@@ -516,5 +516,5 @@
 		dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
 
-		(void) async_data_read_finalize(callid, dentryp->name,
+		(void) async_data_read_finalize(chandle, dentryp->name,
 		    str_size(dentryp->name) + 1);
 		bytes = 1;
@@ -547,8 +547,8 @@
 	 * Receive the write request.
 	 */
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
 		return EINVAL;
 	}
@@ -559,5 +559,5 @@
 	if (pos + size <= nodep->size) {
 		/* The file size is not changing. */
-		(void) async_data_write_finalize(callid, nodep->data + pos,
+		(void) async_data_write_finalize(chandle, nodep->data + pos,
 		    size);
 		goto out;
@@ -573,5 +573,5 @@
 	void *newdata = realloc(nodep->data, nodep->size + delta);
 	if (!newdata) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		size = 0;
 		goto out;
@@ -581,5 +581,5 @@
 	nodep->size += delta;
 	nodep->data = newdata;
-	(void) async_data_write_finalize(callid, nodep->data + pos, size);
+	(void) async_data_write_finalize(chandle, nodep->data + pos, size);
 
 out:
Index: uspace/srv/fs/udf/udf_file.c
===================================================================
--- uspace/srv/fs/udf/udf_file.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/udf/udf_file.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -568,5 +568,5 @@
  *
  * @param read_len Returned value. Length file or part file which we could read.
- * @param callid
+ * @param chandle
  * @param node     UDF node
  * @param pos      Position in file since we have to read.
@@ -576,5 +576,5 @@
  *
  */
-errno_t udf_read_file(size_t *read_len, cap_call_handle_t callid, udf_node_t *node,
+errno_t udf_read_file(size_t *read_len, cap_call_handle_t chandle, udf_node_t *node,
     aoff64_t pos, size_t len)
 {
@@ -598,5 +598,5 @@
 	    BLOCK_FLAGS_NONE);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return rc;
 	}
@@ -619,5 +619,5 @@
 	}
 
-	async_data_read_finalize(callid, block->data + sector_pos, *read_len);
+	async_data_read_finalize(chandle, block->data + sector_pos, *read_len);
 	return block_put(block);
 }
Index: uspace/srv/fs/udf/udf_ops.c
===================================================================
--- uspace/srv/fs/udf/udf_ops.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/fs/udf/udf_ops.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -464,8 +464,8 @@
 	udf_node_t *node = UDF_NODE(rfn);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len = 0;
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EINVAL);
 		udf_node_put(rfn);
 		return EINVAL;
@@ -475,5 +475,5 @@
 		if (pos >= node->data_size) {
 			*rbytes = 0;
-			async_data_read_finalize(callid, NULL, 0);
+			async_data_read_finalize(chandle, NULL, 0);
 			udf_node_put(rfn);
 			return EOK;
@@ -482,9 +482,9 @@
 		size_t read_len = 0;
 		if (node->data == NULL)
-			rc = udf_read_file(&read_len, callid, node, pos, len);
+			rc = udf_read_file(&read_len, chandle, node, pos, len);
 		else {
 			/* File in allocation descriptors area */
 			read_len = (len < node->data_size) ? len : node->data_size;
-			async_data_read_finalize(callid, node->data + pos, read_len);
+			async_data_read_finalize(chandle, node->data + pos, read_len);
 			rc = EOK;
 		}
@@ -505,5 +505,5 @@
 			    fid->lenght_file_id, &node->instance->charset);
 
-			async_data_read_finalize(callid, name, str_size(name) + 1);
+			async_data_read_finalize(chandle, name, str_size(name) + 1);
 			*rbytes = 1;
 			free(name);
@@ -517,5 +517,5 @@
 			*rbytes = 0;
 			udf_node_put(rfn);
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 			return ENOENT;
 		}
Index: uspace/srv/hid/compositor/compositor.c
===================================================================
--- uspace/srv/hid/compositor/compositor.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/compositor/compositor.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -589,29 +589,29 @@
 }
 
-static void comp_window_get_event(window_t *win, cap_call_handle_t iid, ipc_call_t *icall)
+static void comp_window_get_event(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	window_event_t *event = (window_event_t *) prodcons_consume(&win->queue);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
 
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(icall_handle, EINVAL);
 		free(event);
 		return;
 	}
 
-	errno_t rc = async_data_read_finalize(callid, event, len);
+	errno_t rc = async_data_read_finalize(chandle, event, len);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		free(event);
 		return;
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 	free(event);
 }
 
-static void comp_window_damage(window_t *win, cap_call_handle_t iid, ipc_call_t *icall)
+static void comp_window_damage(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	double x = IPC_GET_ARG1(*icall);
@@ -631,8 +631,8 @@
 	}
 
-	async_answer_0(iid, EOK);
-}
-
-static void comp_window_grab(window_t *win, cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void comp_window_grab(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t pos_id = IPC_GET_ARG1(*icall);
@@ -661,5 +661,5 @@
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -693,20 +693,20 @@
 }
 
-static void comp_window_resize(window_t *win, cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void comp_window_resize(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	unsigned int flags;
 
 	/* Start sharing resized window with client. */
-	if (!async_share_out_receive(&callid, &size, &flags)) {
-		async_answer_0(iid, EINVAL);
+	if (!async_share_out_receive(&chandle, &size, &flags)) {
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	void *new_cell_storage;
-	errno_t rc = async_share_out_finalize(callid, &new_cell_storage);
+	errno_t rc = async_share_out_finalize(chandle, &new_cell_storage);
 	if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -717,5 +717,5 @@
 	if (!new_surface) {
 		as_area_destroy(new_cell_storage);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -804,5 +804,5 @@
 	comp_damage(x, y, width, height);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -836,5 +836,5 @@
 }
 
-static void comp_window_close(window_t *win, cap_call_handle_t iid, ipc_call_t *icall)
+static void comp_window_close(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	/* Stop managing the window. */
@@ -876,12 +876,12 @@
 
 	comp_damage(x, y, width, height);
-	async_answer_0(iid, EOK);
-}
-
-static void comp_window_close_request(window_t *win, cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void comp_window_close_request(window_t *win, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
 	if (event == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -891,18 +891,18 @@
 
 	prodcons_produce(&win->queue, &event->link);
-	async_answer_0(iid, EOK);
-}
-
-static void client_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ipc_call_t call;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	service_id_t service_id = (service_id_t) IPC_GET_ARG2(*icall);
 
 	/* Allocate resources for new window and register it to the location service. */
 	if (service_id == winreg_id) {
-		async_answer_0(iid, EOK);
-
-		callid = async_get_call(&call);
+		async_answer_0(icall_handle, EOK);
+
+		chandle = async_get_call(&call);
 		if (IPC_GET_IMETHOD(call) == WINDOW_REGISTER) {
 			fibril_mutex_lock(&window_list_mtx);
@@ -910,5 +910,5 @@
 			window_t *win = window_create();
 			if (!win) {
-				async_answer_2(callid, ENOMEM, 0, 0);
+				async_answer_2(chandle, ENOMEM, 0, 0);
 				fibril_mutex_unlock(&window_list_mtx);
 				return;
@@ -929,5 +929,5 @@
 			if (loc_service_register(name_in, &win->in_dsid) != EOK) {
 				window_destroy(win);
-				async_answer_2(callid, EINVAL, 0, 0);
+				async_answer_2(chandle, EINVAL, 0, 0);
 				fibril_mutex_unlock(&window_list_mtx);
 				return;
@@ -937,5 +937,5 @@
 				loc_service_unregister(win->in_dsid);
 				window_destroy(win);
-				async_answer_2(callid, EINVAL, 0, 0);
+				async_answer_2(chandle, EINVAL, 0, 0);
 				fibril_mutex_unlock(&window_list_mtx);
 				return;
@@ -951,5 +951,5 @@
 			}
 
-			async_answer_2(callid, EOK, win->in_dsid, win->out_dsid);
+			async_answer_2(chandle, EOK, win->in_dsid, win->out_dsid);
 			fibril_mutex_unlock(&window_list_mtx);
 
@@ -960,5 +960,5 @@
 			return;
 		} else {
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			return;
 		}
@@ -978,7 +978,7 @@
 	if (win) {
 		atomic_inc(&win->ref_cnt);
-		async_answer_0(iid, EOK);
+		async_answer_0(icall_handle, EOK);
 	} else {
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -987,8 +987,8 @@
 	if (win->in_dsid == service_id) {
 		while (true) {
-			callid = async_get_call(&call);
+			chandle = async_get_call(&call);
 
 			if (!IPC_GET_IMETHOD(call)) {
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 				atomic_dec(&win->ref_cnt);
 				window_destroy(win);
@@ -998,16 +998,16 @@
 			switch (IPC_GET_IMETHOD(call)) {
 			case WINDOW_GET_EVENT:
-				comp_window_get_event(win, callid, &call);
+				comp_window_get_event(win, chandle, &call);
 				break;
 			default:
-				async_answer_0(callid, EINVAL);
+				async_answer_0(chandle, EINVAL);
 			}
 		}
 	} else if (win->out_dsid == service_id) {
 		while (true) {
-			callid = async_get_call(&call);
+			chandle = async_get_call(&call);
 
 			if (!IPC_GET_IMETHOD(call)) {
-				comp_window_close(win, callid, &call);
+				comp_window_close(win, chandle, &call);
 				atomic_dec(&win->ref_cnt);
 				window_destroy(win);
@@ -1017,11 +1017,11 @@
 			switch (IPC_GET_IMETHOD(call)) {
 			case WINDOW_DAMAGE:
-				comp_window_damage(win, callid, &call);
+				comp_window_damage(win, chandle, &call);
 				break;
 			case WINDOW_GRAB:
-				comp_window_grab(win, callid, &call);
+				comp_window_grab(win, chandle, &call);
 				break;
 			case WINDOW_RESIZE:
-				comp_window_resize(win, callid, &call);
+				comp_window_resize(win, chandle, &call);
 				break;
 			case WINDOW_CLOSE:
@@ -1030,17 +1030,17 @@
 				 * the case when the client is killed abruptly.
 				 */
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 				break;
 			case WINDOW_CLOSE_REQUEST:
-				comp_window_close_request(win, callid, &call);
+				comp_window_close_request(win, chandle, &call);
 				break;
 			default:
-				async_answer_0(callid, EINVAL);
-			}
-		}
-	}
-}
-
-static void comp_mode_change(viewport_t *vp, cap_call_handle_t iid, ipc_call_t *icall)
+				async_answer_0(chandle, EINVAL);
+			}
+		}
+	}
+}
+
+static void comp_mode_change(viewport_t *vp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t mode_idx = IPC_GET_ARG2(*icall);
@@ -1052,5 +1052,5 @@
 	if (rc != EOK) {
 		fibril_mutex_unlock(&viewport_list_mtx);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -1061,5 +1061,5 @@
 	if (!new_surface) {
 		fibril_mutex_unlock(&viewport_list_mtx);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1071,5 +1071,5 @@
 		surface_destroy(new_surface);
 		fibril_mutex_unlock(&viewport_list_mtx);
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -1081,5 +1081,5 @@
 
 	fibril_mutex_unlock(&viewport_list_mtx);
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	comp_restrict_pointers();
@@ -1115,5 +1115,5 @@
 	fibril_mutex_unlock(&window_list_mtx);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	/* All fibrils of the compositor will terminate soon. */
@@ -1121,5 +1121,5 @@
 #endif
 
-static void comp_visualizer_disconnect(viewport_t *vp, cap_call_handle_t iid, ipc_call_t *icall)
+static void comp_visualizer_disconnect(viewport_t *vp, cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	/* Release viewport resources. */
@@ -1131,5 +1131,5 @@
 	fibril_mutex_unlock(&viewport_list_mtx);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	comp_restrict_pointers();
@@ -1137,5 +1137,5 @@
 }
 
-static void vsl_notifications(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void vsl_notifications(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	viewport_t *vp = NULL;
@@ -1155,5 +1155,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -1164,11 +1164,11 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case VISUALIZER_MODE_CHANGE:
-			comp_mode_change(vp, callid, &call);
+			comp_mode_change(vp, chandle, &call);
 			break;
 		case VISUALIZER_DISCONNECT:
-			comp_visualizer_disconnect(vp, callid, &call);
+			comp_visualizer_disconnect(vp, chandle, &call);
 			return;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/hid/console/console.c
===================================================================
--- uspace/srv/hid/console/console.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/console/console.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -507,5 +507,5 @@
 }
 
-static void client_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	console_t *cons = NULL;
@@ -519,5 +519,5 @@
 
 	if (cons == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -526,5 +526,5 @@
 		cons_set_cursor_vis(cons, true);
 
-	con_conn(iid, icall, &cons->srvs);
+	con_conn(icall_handle, icall, &cons->srvs);
 }
 
Index: uspace/srv/hid/input/ctl/kbdev.c
===================================================================
--- uspace/srv/hid/input/ctl/kbdev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/input/ctl/kbdev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -147,5 +147,5 @@
 }
 
-static void kbdev_callback_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void kbdev_callback_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	kbdev_t *kbdev;
@@ -158,7 +158,7 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid;
+		cap_call_handle_t chandle;
 
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		if (!IPC_GET_IMETHOD(call)) {
 			kbdev_destroy(kbdev);
@@ -179,5 +179,5 @@
 		}
 
-		async_answer_0(callid, retval);
+		async_answer_0(chandle, retval);
 	}
 }
Index: uspace/srv/hid/input/input.c
===================================================================
--- uspace/srv/hid/input/input.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/input/input.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -320,17 +320,17 @@
 
 /** New client connection */
-static void client_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	client_t *client = (client_t *) async_get_client_data();
 	if (client == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -340,5 +340,5 @@
 			}
 
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -349,7 +349,7 @@
 			if (client->sess == NULL) {
 				client->sess = sess;
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 			} else
-				async_answer_0(callid, ELIMIT);
+				async_answer_0(chandle, ELIMIT);
 		} else {
 			switch (IPC_GET_IMETHOD(call)) {
@@ -357,8 +357,8 @@
 				active_client = client;
 				client_arbitration();
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 				break;
 			default:
-				async_answer_0(callid, EINVAL);
+				async_answer_0(chandle, EINVAL);
 			}
 		}
Index: uspace/srv/hid/input/proto/mousedev.c
===================================================================
--- uspace/srv/hid/input/proto/mousedev.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/input/proto/mousedev.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -70,5 +70,5 @@
 }
 
-static void mousedev_callback_conn(cap_call_handle_t iid, ipc_call_t *icall,
+static void mousedev_callback_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
@@ -78,5 +78,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -110,5 +110,5 @@
 		}
 
-		async_answer_0(callid, retval);
+		async_answer_0(chandle, retval);
 	}
 }
Index: uspace/srv/hid/isdv4_tablet/main.c
===================================================================
--- uspace/srv/hid/isdv4_tablet/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/isdv4_tablet/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -63,7 +63,7 @@
 }
 
-static void mouse_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
-{
-	async_answer_0(iid, EOK);
+static void mouse_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+{
+	async_answer_0(icall_handle, EOK);
 
 	async_sess_t *sess =
@@ -79,10 +79,10 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
 			break;
 
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 	}
 }
Index: uspace/srv/hid/output/output.c
===================================================================
--- uspace/srv/hid/output/output.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/output/output.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -78,5 +78,5 @@
 }
 
-static void srv_yield(cap_call_handle_t iid, ipc_call_t *icall)
+static void srv_yield(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	errno_t ret = EOK;
@@ -90,8 +90,8 @@
 	}
 
-	async_answer_0(iid, ret);
-}
-
-static void srv_claim(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, ret);
+}
+
+static void srv_claim(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	errno_t ret = EOK;
@@ -105,8 +105,8 @@
 	}
 
-	async_answer_0(iid, ret);
-}
-
-static void srv_get_dimensions(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, ret);
+}
+
+static void srv_get_dimensions(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t cols = MAX_COLS;
@@ -118,8 +118,8 @@
 	}
 
-	async_answer_2(iid, EOK, cols, rows);
-}
-
-static void srv_get_caps(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_2(icall_handle, EOK, cols, rows);
+}
+
+static void srv_get_caps(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	console_caps_t caps = 0;
@@ -131,8 +131,8 @@
 	}
 
-	async_answer_1(iid, EOK, caps);
-}
-
-static frontbuf_t *resolve_frontbuf(sysarg_t handle, cap_call_handle_t iid)
+	async_answer_1(icall_handle, EOK, caps);
+}
+
+static frontbuf_t *resolve_frontbuf(sysarg_t handle, cap_call_handle_t icall_handle)
 {
 	frontbuf_t *frontbuf = NULL;
@@ -145,5 +145,5 @@
 
 	if (frontbuf == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return NULL;
 	}
@@ -152,9 +152,9 @@
 }
 
-static void srv_frontbuf_create(cap_call_handle_t iid, ipc_call_t *icall)
+static void srv_frontbuf_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	frontbuf_t *frontbuf = (frontbuf_t *) malloc(sizeof(frontbuf_t));
 	if (frontbuf == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -162,26 +162,26 @@
 	link_initialize(&frontbuf->link);
 
-	cap_call_handle_t callid;
-	if (!async_share_out_receive(&callid, &frontbuf->size,
+	cap_call_handle_t chandle;
+	if (!async_share_out_receive(&chandle, &frontbuf->size,
 	    &frontbuf->flags)) {
 		free(frontbuf);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_share_out_finalize(callid, &frontbuf->data);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_share_out_finalize(chandle, &frontbuf->data);
 	if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
 		free(frontbuf);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
 
 	list_append(&frontbuf->link, &frontbufs);
-	async_answer_1(iid, EOK, (sysarg_t) frontbuf);
-}
-
-static void srv_frontbuf_destroy(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), iid);
+	async_answer_1(icall_handle, EOK, (sysarg_t) frontbuf);
+}
+
+static void srv_frontbuf_destroy(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
 	if (frontbuf == NULL)
 		return;
@@ -191,10 +191,10 @@
 	free(frontbuf);
 
-	async_answer_0(iid, EOK);
-}
-
-static void srv_cursor_update(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), iid);
+	async_answer_0(icall_handle, EOK);
+}
+
+static void srv_cursor_update(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
 	if (frontbuf == NULL)
 		return;
@@ -223,8 +223,8 @@
 	}
 
-	async_answer_0(iid, EOK);
-}
-
-static void srv_set_style(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void srv_set_style(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	list_foreach(outdevs, link, outdev_t, dev) {
@@ -234,8 +234,8 @@
 	}
 
-	async_answer_0(iid, EOK);
-}
-
-static void srv_set_color(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void srv_set_color(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	list_foreach(outdevs, link, outdev_t, dev) {
@@ -249,8 +249,8 @@
 	}
 
-	async_answer_0(iid, EOK);
-}
-
-static void srv_set_rgb_color(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void srv_set_rgb_color(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	list_foreach(outdevs, link, outdev_t, dev) {
@@ -260,5 +260,5 @@
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -302,7 +302,7 @@
 }
 
-static void srv_update(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), iid);
+static void srv_update(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
 	if (frontbuf == NULL)
 		return;
@@ -349,10 +349,10 @@
 
 
-	async_answer_0(iid, EOK);
-}
-
-static void srv_damage(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), iid);
+	async_answer_0(icall_handle, EOK);
+}
+
+static void srv_damage(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	frontbuf_t *frontbuf = resolve_frontbuf(IPC_GET_ARG1(*icall), icall_handle);
 	if (frontbuf == NULL)
 		return;
@@ -388,18 +388,18 @@
 
 	}
-	async_answer_0(iid, EOK);
-}
-
-static void client_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -407,44 +407,44 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case OUTPUT_YIELD:
-			srv_yield(callid, &call);
+			srv_yield(chandle, &call);
 			break;
 		case OUTPUT_CLAIM:
-			srv_claim(callid, &call);
+			srv_claim(chandle, &call);
 			break;
 		case OUTPUT_GET_DIMENSIONS:
-			srv_get_dimensions(callid, &call);
+			srv_get_dimensions(chandle, &call);
 			break;
 		case OUTPUT_GET_CAPS:
-			srv_get_caps(callid, &call);
+			srv_get_caps(chandle, &call);
 			break;
 
 		case OUTPUT_FRONTBUF_CREATE:
-			srv_frontbuf_create(callid, &call);
+			srv_frontbuf_create(chandle, &call);
 			break;
 		case OUTPUT_FRONTBUF_DESTROY:
-			srv_frontbuf_destroy(callid, &call);
+			srv_frontbuf_destroy(chandle, &call);
 			break;
 
 		case OUTPUT_CURSOR_UPDATE:
-			srv_cursor_update(callid, &call);
+			srv_cursor_update(chandle, &call);
 			break;
 		case OUTPUT_SET_STYLE:
-			srv_set_style(callid, &call);
+			srv_set_style(chandle, &call);
 			break;
 		case OUTPUT_SET_COLOR:
-			srv_set_color(callid, &call);
+			srv_set_color(chandle, &call);
 			break;
 		case OUTPUT_SET_RGB_COLOR:
-			srv_set_rgb_color(callid, &call);
+			srv_set_rgb_color(chandle, &call);
 			break;
 		case OUTPUT_UPDATE:
-			srv_update(callid, &call);
+			srv_update(chandle, &call);
 			break;
 		case OUTPUT_DAMAGE:
-			srv_damage(callid, &call);
+			srv_damage(chandle, &call);
 			break;
 
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/hid/remcons/remcons.c
===================================================================
--- uspace/srv/hid/remcons/remcons.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/remcons/remcons.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -216,15 +216,15 @@
 
 /** Callback when client connects to a telnet terminal. */
-static void client_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Find the user. */
 	telnet_user_t *user = telnet_user_get_for_client_connection(IPC_GET_ARG2(*icall));
 	if (user == NULL) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
 
 	/* Handle messages. */
-	con_conn(iid, icall, &user->srvs);
+	con_conn(icall_handle, icall, &user->srvs);
 }
 
Index: uspace/srv/hid/rfb/main.c
===================================================================
--- uspace/srv/hid/rfb/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/rfb/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -146,7 +146,7 @@
 }
 
-static void client_connection(cap_call_handle_t callid, ipc_call_t *call, void *data)
-{
-	graph_visualizer_connection(vis, callid, call, data);
+static void client_connection(cap_call_handle_t chandle, ipc_call_t *call, void *data)
+{
+	graph_visualizer_connection(vis, chandle, call, data);
 }
 
Index: uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c
===================================================================
--- uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -69,5 +69,5 @@
 static s3c24xx_ts_t *ts;
 
-static void s3c24xx_ts_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void s3c24xx_ts_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg);
 static void s3c24xx_ts_irq_handler(ipc_call_t *call, void *);
@@ -373,12 +373,12 @@
 
 /** Handle mouse client connection. */
-static void s3c24xx_ts_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void s3c24xx_ts_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -388,5 +388,5 @@
 			}
 
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -397,9 +397,9 @@
 			if (ts->client_sess == NULL) {
 				ts->client_sess = sess;
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 			} else
-				async_answer_0(callid, ELIMIT);
+				async_answer_0(chandle, ELIMIT);
 		} else
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 	}
 }
Index: uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c
===================================================================
--- uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -113,10 +113,10 @@
 
 /** Character device connection handler. */
-static void s3c24xx_uart_connection(cap_call_handle_t iid, ipc_call_t *icall,
+static void s3c24xx_uart_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
 	s3c24xx_uart_t *uart = (s3c24xx_uart_t *) arg;
 
-	chardev_conn(iid, icall, &uart->cds);
+	chardev_conn(icall_handle, icall, &uart->cds);
 }
 
Index: uspace/srv/loader/main.c
===================================================================
--- uspace/srv/loader/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/loader/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -92,5 +92,5 @@
 static void ldr_get_taskid(cap_call_handle_t rid, ipc_call_t *request)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	task_id_t task_id;
 	size_t len;
@@ -98,6 +98,6 @@
 	task_id = task_get_id();
 
-	if (!async_data_read_receive(&callid, &len)) {
-		async_answer_0(callid, EINVAL);
+	if (!async_data_read_receive(&chandle, &len)) {
+		async_answer_0(chandle, EINVAL);
 		async_answer_0(rid, EINVAL);
 		return;
@@ -107,5 +107,5 @@
 		len = sizeof(task_id);
 
-	async_data_read_finalize(callid, &task_id, len);
+	async_data_read_finalize(chandle, &task_id, len);
 	async_answer_0(rid, EOK);
 }
@@ -138,7 +138,7 @@
 static void ldr_set_program(cap_call_handle_t rid, ipc_call_t *request)
 {
-	cap_call_handle_t writeid;
+	cap_call_handle_t write_chandle;
 	size_t namesize;
-	if (!async_data_write_receive(&writeid, &namesize)) {
+	if (!async_data_write_receive(&write_chandle, &namesize)) {
 		async_answer_0(rid, EINVAL);
 		return;
@@ -146,5 +146,5 @@
 
 	char* name = malloc(namesize);
-	errno_t rc = async_data_write_finalize(writeid, name, namesize);
+	errno_t rc = async_data_write_finalize(write_chandle, name, namesize);
 	if (rc != EOK) {
 		async_answer_0(rid, EINVAL);
@@ -241,7 +241,7 @@
 	}
 
-	cap_call_handle_t writeid;
+	cap_call_handle_t write_chandle;
 	size_t namesize;
-	if (!async_data_write_receive(&writeid, &namesize)) {
+	if (!async_data_write_receive(&write_chandle, &namesize)) {
 		async_answer_0(rid, EINVAL);
 		return;
@@ -249,5 +249,5 @@
 
 	char* name = malloc(namesize);
-	errno_t rc = async_data_write_finalize(writeid, name, namesize);
+	errno_t rc = async_data_write_finalize(write_chandle, name, namesize);
 	if (rc != EOK) {
 		async_answer_0(rid, EINVAL);
@@ -332,9 +332,9 @@
  * to execute the loaded program).
  */
-static void ldr_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void ldr_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Already have a connection? */
 	if (connected) {
-		async_answer_0(iid, ELIMIT);
+		async_answer_0(icall_handle, ELIMIT);
 		return;
 	}
@@ -343,5 +343,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	/* Ignore parameters, the connection is already open */
@@ -351,5 +351,5 @@
 		errno_t retval;
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -358,23 +358,23 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case LOADER_GET_TASKID:
-			ldr_get_taskid(callid, &call);
+			ldr_get_taskid(chandle, &call);
 			continue;
 		case LOADER_SET_CWD:
-			ldr_set_cwd(callid, &call);
+			ldr_set_cwd(chandle, &call);
 			continue;
 		case LOADER_SET_PROGRAM:
-			ldr_set_program(callid, &call);
+			ldr_set_program(chandle, &call);
 			continue;
 		case LOADER_SET_ARGS:
-			ldr_set_args(callid, &call);
+			ldr_set_args(chandle, &call);
 			continue;
 		case LOADER_ADD_INBOX:
-			ldr_add_inbox(callid, &call);
+			ldr_add_inbox(chandle, &call);
 			continue;
 		case LOADER_LOAD:
-			ldr_load(callid, &call);
+			ldr_load(chandle, &call);
 			continue;
 		case LOADER_RUN:
-			ldr_run(callid, &call);
+			ldr_run(chandle, &call);
 			/* Not reached */
 		default:
@@ -383,5 +383,5 @@
 		}
 
-		async_answer_0(callid, retval);
+		async_answer_0(chandle, retval);
 	}
 }
Index: uspace/srv/locsrv/locsrv.c
===================================================================
--- uspace/srv/locsrv/locsrv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/locsrv/locsrv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -339,8 +339,8 @@
 {
 	ipc_call_t icall;
-	cap_call_handle_t iid = async_get_call(&icall);
+	cap_call_handle_t icall_handle = async_get_call(&icall);
 
 	if (IPC_GET_IMETHOD(icall) != LOC_SERVER_REGISTER) {
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return NULL;
 	}
@@ -349,5 +349,5 @@
 	    (loc_server_t *) malloc(sizeof(loc_server_t));
 	if (server == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return NULL;
 	}
@@ -360,5 +360,5 @@
 	if (rc != EOK) {
 		free(server);
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return NULL;
 	}
@@ -371,5 +371,5 @@
 		free(server->name);
 		free(server);
-		async_answer_0(iid, ENOTSUP);
+		async_answer_0(icall_handle, ENOTSUP);
 		return NULL;
 	}
@@ -400,5 +400,5 @@
 	fibril_mutex_unlock(&servers_list_mutex);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	return server;
@@ -453,9 +453,9 @@
  *
  */
-static void loc_service_register(cap_call_handle_t iid, ipc_call_t *icall,
+static void loc_service_register(cap_call_handle_t icall_handle, ipc_call_t *icall,
     loc_server_t *server)
 {
 	if (server == NULL) {
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -465,5 +465,5 @@
 	    (loc_service_t *) malloc(sizeof(loc_service_t));
 	if (service == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -475,5 +475,5 @@
 	if (rc != EOK) {
 		free(service);
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -483,5 +483,5 @@
 		free(fqsn);
 		free(service);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -497,5 +497,5 @@
 		free(service->name);
 		free(service);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -513,5 +513,5 @@
 		free(service->name);
 		free(service);
-		async_answer_0(iid, EEXIST);
+		async_answer_0(icall_handle, EEXIST);
 		return;
 	}
@@ -535,5 +535,5 @@
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_1(iid, EOK, service->id);
+	async_answer_1(icall_handle, EOK, service->id);
 }
 
@@ -541,5 +541,5 @@
  *
  */
-static void loc_service_unregister(cap_call_handle_t iid, ipc_call_t *icall,
+static void loc_service_unregister(cap_call_handle_t icall_handle, ipc_call_t *icall,
     loc_server_t *server)
 {
@@ -550,5 +550,5 @@
 	if (svc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -565,17 +565,17 @@
 	 */
 	loc_category_change_event();
-	async_answer_0(iid, EOK);
-}
-
-static void loc_category_get_name(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	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;
 	size_t size;
 	size_t act_size;
 	category_t *cat;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -586,6 +586,6 @@
 	if (cat == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -594,20 +594,20 @@
 	if (act_size > size) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, EOVERFLOW);
-		async_answer_0(iid, EOVERFLOW);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, cat->name,
+		async_answer_0(chandle, EOVERFLOW);
+		async_answer_0(icall_handle, EOVERFLOW);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, cat->name,
 	    min(size, act_size));
 
 	fibril_mutex_unlock(&cdir.mutex);
 
-	async_answer_0(iid, retval);
-}
-
-static void loc_service_get_name(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	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;
 	size_t size;
 	size_t act_size;
@@ -615,7 +615,7 @@
 	char *fqn;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -626,6 +626,6 @@
 	if (svc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -633,6 +633,6 @@
 	if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -642,10 +642,10 @@
 		free(fqn);
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, EOVERFLOW);
-		async_answer_0(iid, EOVERFLOW);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, fqn,
+		async_answer_0(chandle, EOVERFLOW);
+		async_answer_0(icall_handle, EOVERFLOW);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, fqn,
 	    min(size, act_size));
 	free(fqn);
@@ -653,17 +653,17 @@
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(iid, retval);
-}
-
-static void loc_service_get_server_name(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	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;
 	size_t size;
 	size_t act_size;
 	loc_service_t *svc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -674,6 +674,6 @@
 	if (svc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -681,6 +681,6 @@
 	if (svc->server == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -689,15 +689,15 @@
 	if (act_size > size) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, EOVERFLOW);
-		async_answer_0(iid, EOVERFLOW);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, svc->server->name,
+		async_answer_0(chandle, EOVERFLOW);
+		async_answer_0(icall_handle, EOVERFLOW);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, svc->server->name,
 	    min(size, act_size));
 
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(iid, retval);
+	async_answer_0(icall_handle, retval);
 }
 
@@ -708,5 +708,5 @@
  *
  */
-static void loc_forward(cap_call_handle_t callid, ipc_call_t *call, void *arg)
+static void loc_forward(cap_call_handle_t chandle, ipc_call_t *call, void *arg)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -721,10 +721,10 @@
 	if ((svc == NULL) || (svc->server == NULL) || (!svc->server->sess)) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
 
 	async_exch_t *exch = async_exchange_begin(svc->server->sess);
-	async_forward_fast(callid, exch, iface, svc->id, 0, IPC_FF_NONE);
+	async_forward_fast(chandle, exch, iface, svc->id, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 
@@ -738,5 +738,5 @@
  *
  */
-static void loc_service_get_id(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_service_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	char *fqsn;
@@ -746,5 +746,5 @@
 	    LOC_NAME_MAXLEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -754,5 +754,5 @@
 	if (!loc_fqsn_split(fqsn, &ns_name, &name)) {
 		free(fqsn);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -781,5 +781,5 @@
 		}
 
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		free(ns_name);
 		free(name);
@@ -788,5 +788,5 @@
 	}
 
-	async_answer_1(iid, EOK, svc->id);
+	async_answer_1(icall_handle, EOK, svc->id);
 
 	fibril_mutex_unlock(&services_list_mutex);
@@ -801,5 +801,5 @@
  *
  */
-static void loc_namespace_get_id(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_namespace_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	char *name;
@@ -809,5 +809,5 @@
 	    LOC_NAME_MAXLEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -834,5 +834,5 @@
 		}
 
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		free(name);
 		fibril_mutex_unlock(&services_list_mutex);
@@ -840,5 +840,5 @@
 	}
 
-	async_answer_1(iid, EOK, namespace->id);
+	async_answer_1(icall_handle, EOK, namespace->id);
 
 	fibril_mutex_unlock(&services_list_mutex);
@@ -855,9 +855,9 @@
  *
  */
-static void loc_callback_create(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_callback_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
 	if (cb_sess == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -866,5 +866,5 @@
 	if (sess == NULL) {
 		free(cb_sess);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -877,5 +877,5 @@
 	fibril_mutex_unlock(&callback_sess_mutex);
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -899,5 +899,5 @@
  *
  */
-static void loc_category_get_id(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_category_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	char *name;
@@ -908,5 +908,5 @@
 	    LOC_NAME_MAXLEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -917,9 +917,9 @@
 	if (cat == NULL) {
 		/* Category not found */
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		goto cleanup;
 	}
 
-	async_answer_1(iid, EOK, cat->id);
+	async_answer_1(icall_handle, EOK, cat->id);
 cleanup:
 	fibril_mutex_unlock(&cdir.mutex);
@@ -927,5 +927,5 @@
 }
 
-static void loc_id_probe(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_id_probe(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -937,21 +937,21 @@
 		    loc_service_find_id(IPC_GET_ARG1(*icall));
 		if (svc == NULL)
-			async_answer_1(iid, EOK, LOC_OBJECT_NONE);
+			async_answer_1(icall_handle, EOK, LOC_OBJECT_NONE);
 		else
-			async_answer_1(iid, EOK, LOC_OBJECT_SERVICE);
+			async_answer_1(icall_handle, EOK, LOC_OBJECT_SERVICE);
 	} else
-		async_answer_1(iid, EOK, LOC_OBJECT_NAMESPACE);
+		async_answer_1(icall_handle, EOK, LOC_OBJECT_NAMESPACE);
 
 	fibril_mutex_unlock(&services_list_mutex);
 }
 
-static void loc_get_namespace_count(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_get_namespace_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fibril_mutex_lock(&services_list_mutex);
-	async_answer_1(iid, EOK, list_count(&namespaces_list));
+	async_answer_1(icall_handle, EOK, list_count(&namespaces_list));
 	fibril_mutex_unlock(&services_list_mutex);
 }
 
-static void loc_get_service_count(cap_call_handle_t iid, ipc_call_t *icall)
+static void loc_get_service_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fibril_mutex_lock(&services_list_mutex);
@@ -960,21 +960,21 @@
 	    loc_namespace_find_id(IPC_GET_ARG1(*icall));
 	if (namespace == NULL)
-		async_answer_0(iid, EEXIST);
+		async_answer_0(icall_handle, EEXIST);
 	else
-		async_answer_1(iid, EOK, namespace->refcnt);
+		async_answer_1(icall_handle, EOK, namespace->refcnt);
 
 	fibril_mutex_unlock(&services_list_mutex);
 }
 
-static void loc_get_categories(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void loc_get_categories(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -983,6 +983,6 @@
 	if (id_buf == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -993,6 +993,6 @@
 	if (rc != EOK) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -1000,23 +1000,23 @@
 	fibril_mutex_unlock(&cdir.mutex);
 
-	errno_t retval = async_data_read_finalize(callid, id_buf, size);
+	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(iid, retval, act_size);
-}
-
-static void loc_get_namespaces(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	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;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if ((size % sizeof(loc_sdesc_t)) != 0) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -1027,6 +1027,6 @@
 	if (count != list_count(&namespaces_list)) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, EOVERFLOW);
-		async_answer_0(iid, EOVERFLOW);
+		async_answer_0(chandle, EOVERFLOW);
+		async_answer_0(icall_handle, EOVERFLOW);
 		return;
 	}
@@ -1035,6 +1035,6 @@
 	if (desc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1047,28 +1047,28 @@
 	}
 
-	errno_t retval = async_data_read_finalize(callid, desc, size);
+	errno_t retval = async_data_read_finalize(chandle, desc, size);
 
 	free(desc);
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(iid, retval);
-}
-
-static void loc_get_services(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, retval);
+}
+
+static void loc_get_services(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	/* FIXME: Use faster algorithm which can make better use
 	   of namespaces */
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if ((size % sizeof(loc_sdesc_t)) != 0) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -1080,6 +1080,6 @@
 	if (namespace == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -1088,6 +1088,6 @@
 	if (count != namespace->refcnt) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, EOVERFLOW);
-		async_answer_0(iid, EOVERFLOW);
+		async_answer_0(chandle, EOVERFLOW);
+		async_answer_0(icall_handle, EOVERFLOW);
 		return;
 	}
@@ -1096,6 +1096,6 @@
 	if (desc == NULL) {
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -1110,22 +1110,22 @@
 	}
 
-	errno_t retval = async_data_read_finalize(callid, desc, size);
+	errno_t retval = async_data_read_finalize(chandle, desc, size);
 
 	free(desc);
 	fibril_mutex_unlock(&services_list_mutex);
 
-	async_answer_0(iid, retval);
-}
-
-static void loc_category_get_svcs(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+	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;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -1136,6 +1136,6 @@
 	if (cat == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -1144,6 +1144,6 @@
 	if (id_buf == NULL) {
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1155,6 +1155,6 @@
 		fibril_mutex_unlock(&cat->mutex);
 		fibril_mutex_unlock(&cdir.mutex);
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -1163,12 +1163,12 @@
 	fibril_mutex_unlock(&cdir.mutex);
 
-	errno_t retval = async_data_read_finalize(callid, id_buf, size);
+	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(iid, retval, act_size);
-}
-
-
-static void loc_null_create(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_1(icall_handle, retval, act_size);
+}
+
+
+static void loc_null_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	fibril_mutex_lock(&null_services_mutex);
@@ -1186,5 +1186,5 @@
 	if (!fnd) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1196,5 +1196,5 @@
 	if (dev_name == NULL) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1204,5 +1204,5 @@
 	if (service == NULL) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1214,5 +1214,5 @@
 		fibril_mutex_lock(&services_list_mutex);
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1241,12 +1241,12 @@
 	fibril_mutex_unlock(&null_services_mutex);
 
-	async_answer_1(iid, EOK, (sysarg_t) i);
-}
-
-static void loc_null_destroy(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_1(icall_handle, EOK, (sysarg_t) i);
+}
+
+static void loc_null_destroy(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t i = IPC_GET_ARG1(*icall);
 	if (i >= NULL_SERVICES) {
-		async_answer_0(iid, ELIMIT);
+		async_answer_0(icall_handle, ELIMIT);
 		return;
 	}
@@ -1256,5 +1256,5 @@
 	if (null_services[i] == NULL) {
 		fibril_mutex_unlock(&null_services_mutex);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -1269,8 +1269,8 @@
 
 	fibril_mutex_unlock(&null_services_mutex);
-	async_answer_0(iid, EOK);
-}
-
-static void loc_service_add_to_cat(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void loc_service_add_to_cat(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	category_t *cat;
@@ -1292,5 +1292,5 @@
 		fibril_mutex_unlock(&cdir.mutex);
 		fibril_mutex_unlock(&services_list_mutex);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -1309,5 +1309,5 @@
 	 */
 	loc_category_change_event();
-	async_answer_0(iid, retval);
+	async_answer_0(icall_handle, retval);
 }
 
@@ -1393,8 +1393,8 @@
  *
  */
-static void loc_connection_supplier(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void loc_connection_supplier(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	loc_server_t *server = loc_server_register();
@@ -1404,5 +1404,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -1412,28 +1412,28 @@
 		case LOC_SERVER_UNREGISTER:
 			if (server == NULL)
-				async_answer_0(callid, ENOENT);
+				async_answer_0(chandle, ENOENT);
 			else
-				async_answer_0(callid, EOK);
+				async_answer_0(chandle, EOK);
 			break;
 		case LOC_SERVICE_ADD_TO_CAT:
 			/* Add service to category */
-			loc_service_add_to_cat(callid, &call);
+			loc_service_add_to_cat(chandle, &call);
 			break;
 		case LOC_SERVICE_REGISTER:
 			/* Register one service */
-			loc_service_register(callid, &call, server);
+			loc_service_register(chandle, &call, server);
 			break;
 		case LOC_SERVICE_UNREGISTER:
 			/* Remove one service */
-			loc_service_unregister(callid, &call, server);
+			loc_service_unregister(chandle, &call, server);
 			break;
 		case LOC_SERVICE_GET_ID:
-			loc_service_get_id(callid, &call);
+			loc_service_get_id(chandle, &call);
 			break;
 		case LOC_NAMESPACE_GET_ID:
-			loc_namespace_get_id(callid, &call);
+			loc_namespace_get_id(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 		}
 	}
@@ -1451,12 +1451,12 @@
  *
  */
-static void loc_connection_consumer(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void loc_connection_consumer(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Accept connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -1465,53 +1465,53 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case LOC_SERVICE_GET_ID:
-			loc_service_get_id(callid, &call);
+			loc_service_get_id(chandle, &call);
 			break;
 		case LOC_SERVICE_GET_NAME:
-			loc_service_get_name(callid, &call);
+			loc_service_get_name(chandle, &call);
 			break;
 		case LOC_SERVICE_GET_SERVER_NAME:
-			loc_service_get_server_name(callid, &call);
+			loc_service_get_server_name(chandle, &call);
 			break;
 		case LOC_NAMESPACE_GET_ID:
-			loc_namespace_get_id(callid, &call);
+			loc_namespace_get_id(chandle, &call);
 			break;
 		case LOC_CALLBACK_CREATE:
-			loc_callback_create(callid, &call);
+			loc_callback_create(chandle, &call);
 			break;
 		case LOC_CATEGORY_GET_ID:
-			loc_category_get_id(callid, &call);
+			loc_category_get_id(chandle, &call);
 			break;
 		case LOC_CATEGORY_GET_NAME:
-			loc_category_get_name(callid, &call);
+			loc_category_get_name(chandle, &call);
 			break;
 		case LOC_CATEGORY_GET_SVCS:
-			loc_category_get_svcs(callid, &call);
+			loc_category_get_svcs(chandle, &call);
 			break;
 		case LOC_ID_PROBE:
-			loc_id_probe(callid, &call);
+			loc_id_probe(chandle, &call);
 			break;
 		case LOC_NULL_CREATE:
-			loc_null_create(callid, &call);
+			loc_null_create(chandle, &call);
 			break;
 		case LOC_NULL_DESTROY:
-			loc_null_destroy(callid, &call);
+			loc_null_destroy(chandle, &call);
 			break;
 		case LOC_GET_NAMESPACE_COUNT:
-			loc_get_namespace_count(callid, &call);
+			loc_get_namespace_count(chandle, &call);
 			break;
 		case LOC_GET_SERVICE_COUNT:
-			loc_get_service_count(callid, &call);
+			loc_get_service_count(chandle, &call);
 			break;
 		case LOC_GET_CATEGORIES:
-			loc_get_categories(callid, &call);
+			loc_get_categories(chandle, &call);
 			break;
 		case LOC_GET_NAMESPACES:
-			loc_get_namespaces(callid, &call);
+			loc_get_namespaces(chandle, &call);
 			break;
 		case LOC_GET_SERVICES:
-			loc_get_services(callid, &call);
+			loc_get_services(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOENT);
+			async_answer_0(chandle, ENOENT);
 		}
 	}
Index: uspace/srv/logger/ctl.c
===================================================================
--- uspace/srv/logger/ctl.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/logger/ctl.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -63,15 +63,15 @@
 }
 
-void logger_connection_handler_control(cap_call_handle_t callid)
+void logger_connection_handler_control(cap_call_handle_t chandle)
 {
 	errno_t rc;
 	int fd;
 
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 	logger_log("control: new client.\n");
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -81,9 +81,9 @@
 		case LOGGER_CONTROL_SET_DEFAULT_LEVEL:
 			rc = set_default_logging_level(IPC_GET_ARG1(call));
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			break;
 		case LOGGER_CONTROL_SET_LOG_LEVEL:
 			rc = handle_log_level_change(IPC_GET_ARG1(call));
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			break;
 		case LOGGER_CONTROL_SET_ROOT:
@@ -93,8 +93,8 @@
 				vfs_put(fd);
 			}
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/srv/logger/main.c
===================================================================
--- uspace/srv/logger/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/logger/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -48,14 +48,14 @@
 #include "logger.h"
 
-static void connection_handler_control(cap_call_handle_t iid, ipc_call_t *icall,
+static void connection_handler_control(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
-	logger_connection_handler_control(iid);
+	logger_connection_handler_control(icall_handle);
 }
 
-static void connection_handler_writer(cap_call_handle_t iid, ipc_call_t *icall,
+static void connection_handler_writer(cap_call_handle_t icall_handle, ipc_call_t *icall,
     void *arg)
 {
-	logger_connection_handler_writer(iid);
+	logger_connection_handler_writer(icall_handle);
 }
 
Index: uspace/srv/logger/writer.c
===================================================================
--- uspace/srv/logger/writer.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/logger/writer.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -94,5 +94,5 @@
 }
 
-void logger_connection_handler_writer(cap_call_handle_t callid)
+void logger_connection_handler_writer(cap_call_handle_t chandle)
 {
 	logger_log_t *log;
@@ -100,5 +100,5 @@
 
 	/* Acknowledge the connection. */
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 
 	logger_log("writer: new client.\n");
@@ -109,5 +109,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -118,22 +118,22 @@
 			log = handle_create_log(IPC_GET_ARG1(call));
 			if (log == NULL) {
-				async_answer_0(callid, ENOMEM);
+				async_answer_0(chandle, ENOMEM);
 				break;
 			}
 			if (!register_log(&registered_logs, log)) {
 				log_unlock(log);
-				async_answer_0(callid, ELIMIT);
+				async_answer_0(chandle, ELIMIT);
 				break;
 			}
 			log_unlock(log);
-			async_answer_1(callid, EOK, (sysarg_t) log);
+			async_answer_1(chandle, EOK, (sysarg_t) log);
 			break;
 		case LOGGER_WRITER_MESSAGE:
 			rc = handle_receive_message(IPC_GET_ARG1(call),
 			    IPC_GET_ARG2(call));
-			async_answer_0(callid, rc);
+			async_answer_0(chandle, rc);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 			break;
 		}
Index: uspace/srv/net/dhcp/main.c
===================================================================
--- uspace/srv/net/dhcp/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/dhcp/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -84,5 +84,5 @@
 }
 
-static void dhcp_link_add_srv(cap_call_handle_t callid, ipc_call_t *call)
+static void dhcp_link_add_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t link_id;
@@ -94,8 +94,8 @@
 
 	rc = dhcpsrv_link_add(link_id);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
-static void dhcp_link_remove_srv(cap_call_handle_t callid, ipc_call_t *call)
+static void dhcp_link_remove_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t link_id;
@@ -107,8 +107,8 @@
 
 	rc = dhcpsrv_link_remove(link_id);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
-static void dhcp_discover_srv(cap_call_handle_t callid, ipc_call_t *call)
+static void dhcp_discover_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t link_id;
@@ -120,22 +120,22 @@
 
 	rc = dhcpsrv_discover(link_id);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
-static void dhcp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void dhcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_client_conn()");
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -143,14 +143,14 @@
 		switch (method) {
 		case DHCP_LINK_ADD:
-			dhcp_link_add_srv(callid, &call);
+			dhcp_link_add_srv(chandle, &call);
 			break;
 		case DHCP_LINK_REMOVE:
-			dhcp_link_remove_srv(callid, &call);
+			dhcp_link_remove_srv(chandle, &call);
 			break;
 		case DHCP_DISCOVER:
-			dhcp_discover_srv(callid, &call);
+			dhcp_discover_srv(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/net/dnsrsrv/dnsrsrv.c
===================================================================
--- uspace/srv/net/dnsrsrv/dnsrsrv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/dnsrsrv/dnsrsrv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -86,5 +86,5 @@
 }
 
-static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t iid,
+static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -97,5 +97,5 @@
 	    DNS_NAME_MAX_SIZE, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -104,32 +104,32 @@
 	rc = dns_name2host(name, &hinfo, ver);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &hinfo->addr, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &hinfo->addr, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -137,34 +137,34 @@
 	size_t act_size = str_size(hinfo->cname);
 	if (act_size > size) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, hinfo->cname, act_size);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, hinfo->cname, act_size);
 	if (rc != EOK)
-		async_answer_0(callid, rc);
-
-	async_answer_0(iid, rc);
+		async_answer_0(chandle, rc);
+
+	async_answer_0(icall_handle, rc);
 
 	dns_hostinfo_destroy(hinfo);
 }
 
-static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t iid,
+static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -172,27 +172,27 @@
 	// FIXME locking
 
-	errno_t rc = async_data_read_finalize(callid, &dns_server_addr, size);
+	errno_t rc = async_data_read_finalize(chandle, &dns_server_addr, size);
 	if (rc != EOK)
-		async_answer_0(callid, rc);
-
-	async_answer_0(iid, rc);
-}
-
-static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t iid,
+		async_answer_0(chandle, rc);
+
+	async_answer_0(icall_handle, rc);
+}
+
+static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -200,14 +200,14 @@
 	// FIXME locking
 
-	errno_t rc = async_data_write_finalize(callid, &dns_server_addr, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-	}
-
-	async_answer_0(iid, rc);
-}
-
-static void dnsr_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	errno_t rc = async_data_write_finalize(chandle, &dns_server_addr, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+	}
+
+	async_answer_0(icall_handle, rc);
+}
+
+static void dnsr_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	dnsr_client_t client;
@@ -216,14 +216,14 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -231,14 +231,14 @@
 		switch (method) {
 		case DNSR_NAME2HOST:
-			dnsr_name2host_srv(&client, callid, &call);
+			dnsr_name2host_srv(&client, chandle, &call);
 			break;
 		case DNSR_GET_SRVADDR:
-			dnsr_get_srvaddr_srv(&client, callid, &call);
+			dnsr_get_srvaddr_srv(&client, chandle, &call);
 			break;
 		case DNSR_SET_SRVADDR:
-			dnsr_set_srvaddr_srv(&client, callid, &call);
+			dnsr_set_srvaddr_srv(&client, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/net/ethip/ethip.c
===================================================================
--- uspace/srv/net/ethip/ethip.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/ethip/ethip.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -63,5 +63,5 @@
 static errno_t ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
 
-static void ethip_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void ethip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 static iplink_ops_t ethip_iplink_ops = {
@@ -142,5 +142,5 @@
 }
 
-static void ethip_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void ethip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ethip_nic_t *nic;
@@ -155,5 +155,5 @@
 	}
 
-	iplink_conn(iid, icall, &nic->iplink);
+	iplink_conn(icall_handle, icall, &nic->iplink);
 }
 
Index: uspace/srv/net/ethip/ethip_nic.c
===================================================================
--- uspace/srv/net/ethip/ethip_nic.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/ethip/ethip_nic.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -52,5 +52,5 @@
 
 static errno_t ethip_nic_open(service_id_t sid);
-static void ethip_nic_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void ethip_nic_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 static LIST_INITIALIZE(ethip_nic_list);
@@ -229,5 +229,5 @@
 }
 
-static void ethip_nic_addr_changed(ethip_nic_t *nic, cap_call_handle_t callid,
+static void ethip_nic_addr_changed(ethip_nic_t *nic, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -255,8 +255,8 @@
 
 	free(addr);
-	async_answer_0(callid, EOK);
-}
-
-static void ethip_nic_received(ethip_nic_t *nic, cap_call_handle_t callid,
+	async_answer_0(chandle, EOK);
+}
+
+static void ethip_nic_received(ethip_nic_t *nic, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -282,15 +282,15 @@
 
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() done, rc=%s", str_error_name(rc));
-	async_answer_0(callid, rc);
-}
-
-static void ethip_nic_device_state(ethip_nic_t *nic, cap_call_handle_t callid,
+	async_answer_0(chandle, rc);
+}
+
+static void ethip_nic_device_state(ethip_nic_t *nic, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_device_state()");
-	async_answer_0(callid, ENOTSUP);
-}
-
-static void ethip_nic_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(chandle, ENOTSUP);
+}
+
+static void ethip_nic_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ethip_nic_t *nic = (ethip_nic_t *)arg;
@@ -300,5 +300,5 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call)) {
@@ -309,15 +309,15 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case NIC_EV_ADDR_CHANGED:
-			ethip_nic_addr_changed(nic, callid, &call);
+			ethip_nic_addr_changed(nic, chandle, &call);
 			break;
 		case NIC_EV_RECEIVED:
-			ethip_nic_received(nic, callid, &call);
+			ethip_nic_received(nic, chandle, &call);
 			break;
 		case NIC_EV_DEVICE_STATE:
-			ethip_nic_device_state(nic, callid, &call);
+			ethip_nic_device_state(nic, chandle, &call);
 			break;
 		default:
 			log_msg(LOG_DEFAULT, LVL_DEBUG, "unknown IPC method: %" PRIun, IPC_GET_IMETHOD(call));
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 		}
 	}
Index: uspace/srv/net/inetsrv/inetcfg.c
===================================================================
--- uspace/srv/net/inetsrv/inetcfg.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/inetsrv/inetcfg.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -253,5 +253,5 @@
 }
 
-static void inetcfg_addr_create_static_srv(cap_call_handle_t iid,
+static void inetcfg_addr_create_static_srv(cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -260,23 +260,23 @@
 	sysarg_t link_id = IPC_GET_ARG1(*icall);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(inet_naddr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	inet_naddr_t naddr;
-	errno_t rc = async_data_write_finalize(callid, &naddr, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+	errno_t rc = async_data_write_finalize(chandle, &naddr, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -286,5 +286,5 @@
 	    0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -293,8 +293,8 @@
 	rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
 	free(name);
-	async_answer_1(iid, rc, addr_id);
-}
-
-static void inetcfg_addr_delete_srv(cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_1(icall_handle, rc, addr_id);
+}
+
+static void inetcfg_addr_delete_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t addr_id;
@@ -306,8 +306,8 @@
 
 	rc = inetcfg_addr_delete(addr_id);
-	async_answer_0(callid, rc);
-}
-
-static void inetcfg_addr_get_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(chandle, rc);
+}
+
+static void inetcfg_addr_get_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
@@ -323,49 +323,49 @@
 	errno_t rc = inetcfg_addr_get(addr_id, &ainfo);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_naddr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &ainfo.naddr, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, ainfo.name,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &ainfo.naddr, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, ainfo.name,
 	    min(size, str_size(ainfo.name)));
 	free(ainfo.name);
 
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_1(iid, rc, ainfo.ilink);
-}
-
-static void inetcfg_addr_get_id_srv(cap_call_handle_t callid, ipc_call_t *call)
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_1(icall_handle, rc, ainfo.ilink);
+}
+
+static void inetcfg_addr_get_id_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	char *name;
@@ -381,5 +381,5 @@
 	    0, NULL);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -388,10 +388,10 @@
 	rc = inetcfg_addr_get_id(name, link_id, &addr_id);
 	free(name);
-	async_answer_1(callid, rc, addr_id);
-}
-
-static void inetcfg_get_addr_list_srv(cap_call_handle_t callid, ipc_call_t *call)
-{
-	cap_call_handle_t rcallid;
+	async_answer_1(chandle, rc, addr_id);
+}
+
+static void inetcfg_get_addr_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
+{
+	cap_call_handle_t rcall_handle;
 	size_t count;
 	size_t max_size;
@@ -403,7 +403,7 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
 
-	if (!async_data_read_receive(&rcallid, &max_size)) {
-		async_answer_0(rcallid, EREFUSED);
-		async_answer_0(callid, EREFUSED);
+	if (!async_data_read_receive(&rcall_handle, &max_size)) {
+		async_answer_0(rcall_handle, EREFUSED);
+		async_answer_0(chandle, EREFUSED);
 		return;
 	}
@@ -411,6 +411,6 @@
 	rc = inetcfg_get_addr_list(&id_buf, &count);
 	if (rc != EOK) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -419,13 +419,13 @@
 	size = min(act_size, max_size);
 
-	errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
+	errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(callid, retval, act_size);
-}
-
-static void inetcfg_get_link_list_srv(cap_call_handle_t callid, ipc_call_t *call)
-{
-	cap_call_handle_t rcallid;
+	async_answer_1(chandle, retval, act_size);
+}
+
+static void inetcfg_get_link_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
+{
+	cap_call_handle_t rcall_handle;
 	size_t count;
 	size_t max_size;
@@ -437,7 +437,7 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
 
-	if (!async_data_read_receive(&rcallid, &max_size)) {
-		async_answer_0(rcallid, EREFUSED);
-		async_answer_0(callid, EREFUSED);
+	if (!async_data_read_receive(&rcall_handle, &max_size)) {
+		async_answer_0(rcall_handle, EREFUSED);
+		async_answer_0(chandle, EREFUSED);
 		return;
 	}
@@ -445,6 +445,6 @@
 	rc = inetcfg_get_link_list(&id_buf, &count);
 	if (rc != EOK) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -453,13 +453,13 @@
 	size = min(act_size, max_size);
 
-	errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
+	errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(callid, retval, act_size);
-}
-
-static void inetcfg_get_sroute_list_srv(cap_call_handle_t callid, ipc_call_t *call)
-{
-	cap_call_handle_t rcallid;
+	async_answer_1(chandle, retval, act_size);
+}
+
+static void inetcfg_get_sroute_list_srv(cap_call_handle_t chandle, ipc_call_t *call)
+{
+	cap_call_handle_t rcall_handle;
 	size_t count;
 	size_t max_size;
@@ -471,7 +471,7 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
 
-	if (!async_data_read_receive(&rcallid, &max_size)) {
-		async_answer_0(rcallid, EREFUSED);
-		async_answer_0(callid, EREFUSED);
+	if (!async_data_read_receive(&rcall_handle, &max_size)) {
+		async_answer_0(rcall_handle, EREFUSED);
+		async_answer_0(chandle, EREFUSED);
 		return;
 	}
@@ -479,6 +479,6 @@
 	rc = inetcfg_get_sroute_list(&id_buf, &count);
 	if (rc != EOK) {
-		async_answer_0(rcallid, rc);
-		async_answer_0(callid, rc);
+		async_answer_0(rcall_handle, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -487,11 +487,11 @@
 	size = min(act_size, max_size);
 
-	errno_t retval = async_data_read_finalize(rcallid, id_buf, size);
+	errno_t retval = async_data_read_finalize(rcall_handle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(callid, retval, act_size);
-}
-
-static void inetcfg_link_add_srv(cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_1(chandle, retval, act_size);
+}
+
+static void inetcfg_link_add_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t link_id;
@@ -503,11 +503,11 @@
 
 	rc = inetcfg_link_add(link_id);
-	async_answer_0(callid, rc);
-}
-
-static void inetcfg_link_get_srv(cap_call_handle_t callid, ipc_call_t *call)
-{
-	cap_call_handle_t name_callid;
-	cap_call_handle_t laddr_callid;
+	async_answer_0(chandle, rc);
+}
+
+static void inetcfg_link_get_srv(cap_call_handle_t chandle, ipc_call_t *call)
+{
+	cap_call_handle_t name_chandle;
+	cap_call_handle_t laddr_chandle;
 	size_t name_max_size;
 	size_t laddr_max_size;
@@ -522,13 +522,13 @@
 	linfo.name = NULL;
 
-	if (!async_data_read_receive(&name_callid, &name_max_size)) {
-		async_answer_0(name_callid, EREFUSED);
-		async_answer_0(callid, EREFUSED);
-		return;
-	}
-
-	if (!async_data_read_receive(&laddr_callid, &laddr_max_size)) {
-		async_answer_0(name_callid, EREFUSED);
-		async_answer_0(callid, EREFUSED);
+	if (!async_data_read_receive(&name_chandle, &name_max_size)) {
+		async_answer_0(name_chandle, EREFUSED);
+		async_answer_0(chandle, EREFUSED);
+		return;
+	}
+
+	if (!async_data_read_receive(&laddr_chandle, &laddr_max_size)) {
+		async_answer_0(name_chandle, EREFUSED);
+		async_answer_0(chandle, EREFUSED);
 		return;
 	}
@@ -536,28 +536,28 @@
 	rc = inetcfg_link_get(link_id, &linfo);
 	if (rc != EOK) {
-		async_answer_0(laddr_callid, rc);
-		async_answer_0(name_callid, rc);
-		async_answer_0(callid, rc);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(name_callid, linfo.name,
+		async_answer_0(laddr_chandle, rc);
+		async_answer_0(name_chandle, rc);
+		async_answer_0(chandle, rc);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(name_chandle, linfo.name,
 	    min(name_max_size, str_size(linfo.name)));
 	if (retval != EOK) {
 		free(linfo.name);
-		async_answer_0(laddr_callid, retval);
-		async_answer_0(callid, retval);
-		return;
-	}
-
-	retval = async_data_read_finalize(laddr_callid, &linfo.mac_addr,
+		async_answer_0(laddr_chandle, retval);
+		async_answer_0(chandle, retval);
+		return;
+	}
+
+	retval = async_data_read_finalize(laddr_chandle, &linfo.mac_addr,
 	    min(laddr_max_size, sizeof(linfo.mac_addr)));
 
 	free(linfo.name);
 
-	async_answer_1(callid, retval, linfo.def_mtu);
-}
-
-static void inetcfg_link_remove_srv(cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_1(chandle, retval, linfo.def_mtu);
+}
+
+static void inetcfg_link_remove_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t link_id;
@@ -569,51 +569,51 @@
 
 	rc = inetcfg_link_remove(link_id);
-	async_answer_0(callid, rc);
-}
-
-static void inetcfg_sroute_create_srv(cap_call_handle_t iid,
+	async_answer_0(chandle, rc);
+}
+
+static void inetcfg_sroute_create_srv(cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(inet_naddr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	inet_naddr_t dest;
-	errno_t rc = async_data_write_finalize(callid, &dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+	errno_t rc = async_data_write_finalize(chandle, &dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	inet_addr_t router;
-	rc = async_data_write_finalize(callid, &router, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+	rc = async_data_write_finalize(chandle, &router, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -623,5 +623,5 @@
 	    0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -630,8 +630,8 @@
 	rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
 	free(name);
-	async_answer_1(iid, rc, sroute_id);
-}
-
-static void inetcfg_sroute_delete_srv(cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_1(icall_handle, rc, sroute_id);
+}
+
+static void inetcfg_sroute_delete_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	sysarg_t sroute_id;
@@ -643,8 +643,8 @@
 
 	rc = inetcfg_sroute_delete(sroute_id);
-	async_answer_0(callid, rc);
-}
-
-static void inetcfg_sroute_get_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_0(chandle, rc);
+}
+
+static void inetcfg_sroute_get_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
@@ -660,62 +660,62 @@
 	errno_t rc = inetcfg_sroute_get(sroute_id, &srinfo);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	cap_call_handle_t callid;
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_naddr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &srinfo.dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &srinfo.dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &srinfo.router, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, srinfo.name,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &srinfo.router, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, srinfo.name,
 	    min(size, str_size(srinfo.name)));
 	free(srinfo.name);
 
-	async_answer_0(iid, rc);
-}
-
-static void inetcfg_sroute_get_id_srv(cap_call_handle_t callid, ipc_call_t *call)
+	async_answer_0(icall_handle, rc);
+}
+
+static void inetcfg_sroute_get_id_srv(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	char *name;
@@ -728,5 +728,5 @@
 	    0, NULL);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -735,17 +735,17 @@
 	rc = inetcfg_sroute_get_id(name, &sroute_id);
 	free(name);
-	async_answer_1(callid, rc, sroute_id);
-}
-
-void inet_cfg_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_1(chandle, rc, sroute_id);
+}
+
+void inet_cfg_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_cfg_conn()");
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
@@ -753,5 +753,5 @@
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -759,47 +759,47 @@
 		switch (method) {
 		case INETCFG_ADDR_CREATE_STATIC:
-			inetcfg_addr_create_static_srv(callid, &call);
+			inetcfg_addr_create_static_srv(chandle, &call);
 			break;
 		case INETCFG_ADDR_DELETE:
-			inetcfg_addr_delete_srv(callid, &call);
+			inetcfg_addr_delete_srv(chandle, &call);
 			break;
 		case INETCFG_ADDR_GET:
-			inetcfg_addr_get_srv(callid, &call);
+			inetcfg_addr_get_srv(chandle, &call);
 			break;
 		case INETCFG_ADDR_GET_ID:
-			inetcfg_addr_get_id_srv(callid, &call);
+			inetcfg_addr_get_id_srv(chandle, &call);
 			break;
 		case INETCFG_GET_ADDR_LIST:
-			inetcfg_get_addr_list_srv(callid, &call);
+			inetcfg_get_addr_list_srv(chandle, &call);
 			break;
 		case INETCFG_GET_LINK_LIST:
-			inetcfg_get_link_list_srv(callid, &call);
+			inetcfg_get_link_list_srv(chandle, &call);
 			break;
 		case INETCFG_GET_SROUTE_LIST:
-			inetcfg_get_sroute_list_srv(callid, &call);
+			inetcfg_get_sroute_list_srv(chandle, &call);
 			break;
 		case INETCFG_LINK_ADD:
-			inetcfg_link_add_srv(callid, &call);
+			inetcfg_link_add_srv(chandle, &call);
 			break;
 		case INETCFG_LINK_GET:
-			inetcfg_link_get_srv(callid, &call);
+			inetcfg_link_get_srv(chandle, &call);
 			break;
 		case INETCFG_LINK_REMOVE:
-			inetcfg_link_remove_srv(callid, &call);
+			inetcfg_link_remove_srv(chandle, &call);
 			break;
 		case INETCFG_SROUTE_CREATE:
-			inetcfg_sroute_create_srv(callid, &call);
+			inetcfg_sroute_create_srv(chandle, &call);
 			break;
 		case INETCFG_SROUTE_DELETE:
-			inetcfg_sroute_delete_srv(callid, &call);
+			inetcfg_sroute_delete_srv(chandle, &call);
 			break;
 		case INETCFG_SROUTE_GET:
-			inetcfg_sroute_get_srv(callid, &call);
+			inetcfg_sroute_get_srv(chandle, &call);
 			break;
 		case INETCFG_SROUTE_GET_ID:
-			inetcfg_sroute_get_id_srv(callid, &call);
+			inetcfg_sroute_get_id_srv(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/net/inetsrv/inetping.c
===================================================================
--- uspace/srv/net/inetsrv/inetping.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/inetsrv/inetping.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -136,5 +136,5 @@
 }
 
-static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t iid,
+static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -146,41 +146,41 @@
 	sdu.seq_no = IPC_GET_ARG1(*icall);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(sdu.src)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &sdu.src, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &sdu.src, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(sdu.dest)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &sdu.dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &sdu.dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -189,5 +189,5 @@
 	    &sdu.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -196,13 +196,13 @@
 	free(sdu.data);
 
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
 static void inetping_get_srcaddr_srv(inetping_client_t *client,
-    cap_call_handle_t iid, ipc_call_t *icall)
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
 
@@ -210,20 +210,20 @@
 	inet_addr_t remote;
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(remote)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_data_write_finalize(callid, &remote, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_data_write_finalize(chandle, &remote, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -231,25 +231,25 @@
 	rc = inetping_get_srcaddr(client, &remote, &local);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(local)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &local, size);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &local, size);
 	if (rc != EOK)
-		async_answer_0(callid, rc);
-
-	async_answer_0(iid, rc);
+		async_answer_0(chandle, rc);
+
+	async_answer_0(icall_handle, rc);
 }
 
@@ -281,10 +281,10 @@
 }
 
-void inetping_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void inetping_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	inetping_client_t client;
@@ -295,10 +295,10 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -306,11 +306,11 @@
 		switch (method) {
 		case INETPING_SEND:
-			inetping_send_srv(&client, callid, &call);
+			inetping_send_srv(&client, chandle, &call);
 			break;
 		case INETPING_GET_SRCADDR:
-			inetping_get_srcaddr_srv(&client, callid, &call);
+			inetping_get_srcaddr_srv(&client, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/net/inetsrv/inetsrv.c
===================================================================
--- uspace/srv/net/inetsrv/inetsrv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/inetsrv/inetsrv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -120,5 +120,5 @@
 }
 
-static void inet_callback_create_srv(inet_client_t *client, cap_call_handle_t callid,
+static void inet_callback_create_srv(inet_client_t *client, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -127,10 +127,10 @@
 	async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
 	if (sess == NULL) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
 
 	client->sess = sess;
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 }
 
@@ -230,5 +230,5 @@
 }
 
-static void inet_get_srcaddr_srv(inet_client_t *client, cap_call_handle_t iid,
+static void inet_get_srcaddr_srv(inet_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -237,23 +237,23 @@
 	uint8_t tos = IPC_GET_ARG1(*icall);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
 
 	inet_addr_t remote;
-	errno_t rc = async_data_write_finalize(callid, &remote, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+	errno_t rc = async_data_write_finalize(chandle, &remote, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 	}
 
@@ -261,31 +261,31 @@
 	rc = inet_get_srcaddr(&remote, tos, &local);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &local, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, rc);
-}
-
-static void inet_send_srv(inet_client_t *client, cap_call_handle_t iid,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &local, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, rc);
+}
+
+static void inet_send_srv(inet_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -300,40 +300,40 @@
 	int df = IPC_GET_ARG4(*icall);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-	}
-
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	errno_t rc = async_data_write_finalize(chandle, &dgram.src, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+	}
+
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_addr_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &dgram.dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &dgram.dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 	}
 
@@ -341,5 +341,5 @@
 	    &dgram.size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -348,8 +348,8 @@
 
 	free(dgram.data);
-	async_answer_0(iid, rc);
-}
-
-static void inet_set_proto_srv(inet_client_t *client, cap_call_handle_t callid,
+	async_answer_0(icall_handle, rc);
+}
+
+static void inet_set_proto_srv(inet_client_t *client, cap_call_handle_t chandle,
     ipc_call_t *call)
 {
@@ -360,10 +360,10 @@
 
 	if (proto > UINT8_MAX) {
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		return;
 	}
 
 	client->protocol = proto;
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 }
 
@@ -387,5 +387,5 @@
 }
 
-static void inet_default_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void inet_default_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	inet_client_t client;
@@ -394,5 +394,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	inet_client_init(&client);
@@ -400,10 +400,10 @@
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -411,17 +411,17 @@
 		switch (method) {
 		case INET_CALLBACK_CREATE:
-			inet_callback_create_srv(&client, callid, &call);
+			inet_callback_create_srv(&client, chandle, &call);
 			break;
 		case INET_GET_SRCADDR:
-			inet_get_srcaddr_srv(&client, callid, &call);
+			inet_get_srcaddr_srv(&client, chandle, &call);
 			break;
 		case INET_SEND:
-			inet_send_srv(&client, callid, &call);
+			inet_send_srv(&client, chandle, &call);
 			break;
 		case INET_SET_PROTO:
-			inet_set_proto_srv(&client, callid, &call);
+			inet_set_proto_srv(&client, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
Index: uspace/srv/net/loopip/loopip.c
===================================================================
--- uspace/srv/net/loopip/loopip.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/loopip/loopip.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -59,5 +59,5 @@
 static errno_t loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
 
-static void loopip_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void loopip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 static iplink_ops_t loopip_iplink_ops = {
@@ -148,8 +148,8 @@
 }
 
-static void loopip_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void loopip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_client_conn()");
-	iplink_conn(iid, icall, &loopip_iplink);
+	iplink_conn(icall_handle, icall, &loopip_iplink);
 }
 
Index: uspace/srv/net/nconfsrv/nconfsrv.c
===================================================================
--- uspace/srv/net/nconfsrv/nconfsrv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/nconfsrv/nconfsrv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -54,5 +54,5 @@
 #define NAME "nconfsrv"
 
-static void ncs_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+static void ncs_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 static errno_t ncs_init(void)
@@ -98,7 +98,7 @@
 }
 
-static void ncs_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void ncs_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
-	async_answer_0(iid, ENOTSUP);
+	async_answer_0(icall_handle, ENOTSUP);
 }
 
Index: uspace/srv/net/slip/slip.c
===================================================================
--- uspace/srv/net/slip/slip.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/slip/slip.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -199,8 +199,8 @@
 }
 
-static void slip_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void slip_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_client_conn()");
-	iplink_conn(iid, icall, &slip_iplink);
+	iplink_conn(icall_handle, icall, &slip_iplink);
 }
 
Index: uspace/srv/net/tcp/service.c
===================================================================
--- uspace/srv/net/tcp/service.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/tcp/service.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -724,10 +724,10 @@
  * Handle client request to create callback session.
  *
- * @param client  TCP client
- * @param iid     Async request ID
- * @param icall   Async request data
- */
-static void tcp_callback_create_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_callback_create_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_callback_create_srv()");
@@ -735,10 +735,10 @@
 	async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
 	if (sess == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
 
 	client->sess = sess;
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -747,12 +747,12 @@
  * Handle client request to create connection.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_create_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_conn_create_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	inet_ep2_t epp;
@@ -762,20 +762,20 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_ep2_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &epp, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &epp, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -783,9 +783,9 @@
 	rc = tcp_conn_create_impl(client, &epp, &conn_id);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_1(iid, EOK, conn_id);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, conn_id);
 }
 
@@ -794,10 +794,10 @@
  * Handle client request to destroy connection.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_destroy_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle 
+ * @param icall         Async request data
+ */
+static void tcp_conn_destroy_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t conn_id;
@@ -808,5 +808,5 @@
 	conn_id = IPC_GET_ARG1(*icall);
 	rc = tcp_conn_destroy_impl(client, conn_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -815,12 +815,12 @@
  * Handle client request to create listener.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_listener_create_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle 
+ * @param icall         Async request data
+ */
+static void tcp_listener_create_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	inet_ep_t ep;
@@ -830,20 +830,20 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_ep_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &ep, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &ep, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -851,9 +851,9 @@
 	rc = tcp_listener_create_impl(client, &ep, &lst_id);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_1(iid, EOK, lst_id);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, lst_id);
 }
 
@@ -862,10 +862,10 @@
  * Handle client request to destroy listener.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_listener_destroy_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_listener_destroy_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t lst_id;
@@ -876,5 +876,5 @@
 	lst_id = IPC_GET_ARG1(*icall);
 	rc = tcp_listener_destroy_impl(client, lst_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -883,10 +883,10 @@
  * Handle client request to send FIN.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_send_fin_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle 
+ * @param icall         Async request data
+ */
+static void tcp_conn_send_fin_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t conn_id;
@@ -897,5 +897,5 @@
 	conn_id = IPC_GET_ARG1(*icall);
 	rc = tcp_conn_send_fin_impl(client, conn_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -904,10 +904,10 @@
  * Handle client request to push connection.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_push_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_conn_push_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t conn_id;
@@ -918,5 +918,5 @@
 	conn_id = IPC_GET_ARG1(*icall);
 	rc = tcp_conn_push_impl(client, conn_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -925,10 +925,10 @@
  * Handle client request to reset connection.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_reset_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_conn_reset_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	sysarg_t conn_id;
@@ -939,5 +939,5 @@
 	conn_id = IPC_GET_ARG1(*icall);
 	rc = tcp_conn_reset_impl(client, conn_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -946,12 +946,12 @@
  * Handle client request to send data via connection.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_send_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_conn_send_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	sysarg_t conn_id;
@@ -963,13 +963,13 @@
 	/* Receive message data */
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size > MAX_MSG_SIZE) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -977,13 +977,13 @@
 	data = malloc(size);
 	if (data == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, data, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, data, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
@@ -994,10 +994,10 @@
 	rc = tcp_conn_send_impl(client, conn_id, data, size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 	free(data);
 }
@@ -1007,12 +1007,12 @@
  * Handle client request to read received data via connection without blocking.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_recv_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_conn_recv_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	sysarg_t conn_id;
 	size_t size, rsize;
@@ -1024,7 +1024,7 @@
 	conn_id = IPC_GET_ARG1(*icall);
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -1033,6 +1033,6 @@
 	data = malloc(size);
 	if (data == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1040,18 +1040,18 @@
 	rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
 	}
 
-	rc = async_data_read_finalize(callid, data, size);
-	if (rc != EOK) {
-		async_answer_0(iid, rc);
+	rc = async_data_read_finalize(chandle, data, size);
+	if (rc != EOK) {
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
 	}
 
-	async_answer_1(iid, EOK, rsize);
+	async_answer_1(icall_handle, EOK, rsize);
 	free(data);
 
@@ -1063,12 +1063,12 @@
  * Handle client request to read received data via connection with blocking.
  *
- * @param client   TCP client
- * @param iid      Async request ID
- * @param icall    Async request data
- */
-static void tcp_conn_recv_wait_srv(tcp_client_t *client, cap_call_handle_t iid,
-    ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+ * @param client        TCP client
+ * @param icall_handle  Async request call handle
+ * @param icall         Async request data
+ */
+static void tcp_conn_recv_wait_srv(tcp_client_t *client,
+    cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	sysarg_t conn_id;
 	size_t size, rsize;
@@ -1080,8 +1080,8 @@
 	conn_id = IPC_GET_ARG1(*icall);
 
-	if (!async_data_read_receive(&callid, &size)) {
+	if (!async_data_read_receive(&chandle, &size)) {
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - data_receive failed");
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -1091,6 +1091,6 @@
 	if (data == NULL) {
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - allocation failed");
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -1099,14 +1099,14 @@
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - recv_impl failed rc=%s", str_error_name(rc));
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
 	}
 
-	rc = async_data_read_finalize(callid, data, size);
+	rc = async_data_read_finalize(chandle, data, size);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - finalize failed");
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
@@ -1114,5 +1114,5 @@
 
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): rsize=%zu", size);
-	async_answer_1(iid, EOK, rsize);
+	async_answer_1(icall_handle, EOK, rsize);
 	free(data);
 
@@ -1168,14 +1168,15 @@
 /** Handle TCP client connection.
  *
- * @param iid   Connect call ID
- * @param icall Connect call data
- * @param arg   Connection argument
- */
-static void tcp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+ * @param icall_handle  Connect call handle
+ * @param icall         Connect call data
+ * @param arg           Connection argument
+ */
+static void tcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
+    void *arg)
 {
 	tcp_client_t client;
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn() - client=%p",
@@ -1187,5 +1188,5 @@
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: wait req");
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
@@ -1194,5 +1195,5 @@
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -1200,38 +1201,38 @@
 		switch (method) {
 		case TCP_CALLBACK_CREATE:
-			tcp_callback_create_srv(&client, callid, &call);
+			tcp_callback_create_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_CREATE:
-			tcp_conn_create_srv(&client, callid, &call);
+			tcp_conn_create_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_DESTROY:
-			tcp_conn_destroy_srv(&client, callid, &call);
+			tcp_conn_destroy_srv(&client, chandle, &call);
 			break;
 		case TCP_LISTENER_CREATE:
-			tcp_listener_create_srv(&client, callid, &call);
+			tcp_listener_create_srv(&client, chandle, &call);
 			break;
 		case TCP_LISTENER_DESTROY:
-			tcp_listener_destroy_srv(&client, callid, &call);
+			tcp_listener_destroy_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_SEND_FIN:
-			tcp_conn_send_fin_srv(&client, callid, &call);
+			tcp_conn_send_fin_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_PUSH:
-			tcp_conn_push_srv(&client, callid, &call);
+			tcp_conn_push_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_RESET:
-			tcp_conn_reset_srv(&client, callid, &call);
+			tcp_conn_reset_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_SEND:
-			tcp_conn_send_srv(&client, callid, &call);
+			tcp_conn_send_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_RECV:
-			tcp_conn_recv_srv(&client, callid, &call);
+			tcp_conn_recv_srv(&client, chandle, &call);
 			break;
 		case TCP_CONN_RECV_WAIT:
-			tcp_conn_recv_wait_srv(&client, callid, &call);
+			tcp_conn_recv_wait_srv(&client, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
Index: uspace/srv/net/udp/service.c
===================================================================
--- uspace/srv/net/udp/service.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/net/udp/service.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -335,5 +335,5 @@
  * @param icall    Async request data
  */
-static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -342,10 +342,10 @@
 	async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
 	if (sess == NULL) {
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
 
 	client->sess = sess;
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -358,8 +358,8 @@
  * @param icall    Async request data
  */
-static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
 	inet_ep2_t epp;
@@ -369,20 +369,20 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_ep2_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &epp, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &epp, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -390,9 +390,9 @@
 	rc = udp_assoc_create_impl(client, &epp, &assoc_id);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_1(iid, EOK, assoc_id);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_1(icall_handle, EOK, assoc_id);
 }
 
@@ -405,5 +405,5 @@
  * @param icall    Async request data
  */
-static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -415,5 +415,5 @@
 	assoc_id = IPC_GET_ARG1(*icall);
 	rc = udp_assoc_destroy_impl(client, assoc_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -426,5 +426,5 @@
  * @param icall    Async request data
  */
-static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -436,5 +436,5 @@
 	assoc_id = IPC_GET_ARG1(*icall);
 	rc = udp_assoc_set_nolocal_impl(client, assoc_id);
-	async_answer_0(iid, rc);
+	async_answer_0(icall_handle, rc);
 }
 
@@ -447,8 +447,8 @@
  * @param icall    Async request data
  */
-static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
 	inet_ep_t dest;
@@ -461,20 +461,20 @@
 	/* Receive dest */
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(inet_ep_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_write_finalize(callid, &dest, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_write_finalize(chandle, &dest, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -482,13 +482,13 @@
 	/* Receive message data */
 
-	if (!async_data_write_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_write_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size > MAX_MSG_SIZE) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
 		return;
 	}
@@ -496,12 +496,12 @@
 	data = malloc(size);
 	if (data == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
-	}
-
-	rc = async_data_write_finalize(callid, data, size);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
+	}
+
+	rc = async_data_write_finalize(chandle, data, size);
+	if (rc != EOK) {
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
@@ -512,10 +512,10 @@
 	rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		free(data);
 		return;
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 	free(data);
 }
@@ -545,8 +545,8 @@
  * @param icall    Async request data
  */
-static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
 	udp_crcv_queue_entry_t *enext;
@@ -557,20 +557,20 @@
 	enext = udp_rmsg_get_next(client);
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (enext == NULL) {
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &enext->epp.remote,
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &enext->epp.remote,
 	    max(size, (size_t)sizeof(inet_ep_t)));
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -581,5 +581,5 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
 	    "size=%zu", assoc_id, size);
-	async_answer_2(iid, EOK, assoc_id, size);
+	async_answer_2(icall_handle, EOK, assoc_id, size);
 }
 
@@ -592,8 +592,8 @@
  * @param icall    Async request data
  */
-static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t msg_size;
 	udp_crcv_queue_entry_t *enext;
@@ -608,13 +608,13 @@
 	enext = udp_rmsg_get_next(client);
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (enext == NULL) {
-		async_answer_0(callid, ENOENT);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(chandle, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -624,16 +624,16 @@
 
 	if (off > msg_size) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, data, min(msg_size - off, size));
-	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, data, min(msg_size - off, size));
+	if (rc != EOK) {
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
 }
@@ -648,5 +648,5 @@
  * @param icall    Async request data
  */
-static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t iid,
+static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     ipc_call_t *icall)
 {
@@ -658,5 +658,5 @@
 	if (enext == NULL) {
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -665,5 +665,5 @@
 	udp_msg_delete(enext->msg);
 	free(enext);
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
@@ -674,5 +674,5 @@
  * @param arg   Connection argument
  */
-static void udp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	udp_client_t client;
@@ -680,5 +680,5 @@
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
@@ -691,5 +691,5 @@
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
@@ -698,5 +698,5 @@
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			break;
 		}
@@ -704,29 +704,29 @@
 		switch (method) {
 		case UDP_CALLBACK_CREATE:
-			udp_callback_create_srv(&client, callid, &call);
+			udp_callback_create_srv(&client, chandle, &call);
 			break;
 		case UDP_ASSOC_CREATE:
-			udp_assoc_create_srv(&client, callid, &call);
+			udp_assoc_create_srv(&client, chandle, &call);
 			break;
 		case UDP_ASSOC_DESTROY:
-			udp_assoc_destroy_srv(&client, callid, &call);
+			udp_assoc_destroy_srv(&client, chandle, &call);
 			break;
 		case UDP_ASSOC_SET_NOLOCAL:
-			udp_assoc_set_nolocal_srv(&client, callid, &call);
+			udp_assoc_set_nolocal_srv(&client, chandle, &call);
 			break;
 		case UDP_ASSOC_SEND_MSG:
-			udp_assoc_send_msg_srv(&client, callid, &call);
+			udp_assoc_send_msg_srv(&client, chandle, &call);
 			break;
 		case UDP_RMSG_INFO:
-			udp_rmsg_info_srv(&client, callid, &call);
+			udp_rmsg_info_srv(&client, chandle, &call);
 			break;
 		case UDP_RMSG_READ:
-			udp_rmsg_read_srv(&client, callid, &call);
+			udp_rmsg_read_srv(&client, chandle, &call);
 			break;
 		case UDP_RMSG_DISCARD:
-			udp_rmsg_discard_srv(&client, callid, &call);
+			udp_rmsg_discard_srv(&client, chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
Index: uspace/srv/ns/clonable.c
===================================================================
--- uspace/srv/ns/clonable.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/ns/clonable.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -48,5 +48,5 @@
 	service_t service;
 	iface_t iface;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	sysarg_t arg3;
 } cs_req_t;
@@ -75,5 +75,5 @@
  */
 void register_clonable(service_t service, sysarg_t phone, ipc_call_t *call,
-    cap_call_handle_t callid)
+    cap_call_handle_t chandle)
 {
 	link_t *req_link = list_first(&cs_req);
@@ -81,5 +81,5 @@
 		/* There was no pending connection request. */
 		printf("%s: Unexpected clonable server.\n", NAME);
-		async_answer_0(callid, EBUSY);
+		async_answer_0(chandle, EBUSY);
 		return;
 	}
@@ -91,12 +91,12 @@
 	assert(csr->service == SERVICE_LOADER);
 
-	async_answer_0(callid, EOK);
+	async_answer_0(chandle, EOK);
 
 	async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
 	if (sess == NULL)
-		async_answer_0(callid, EIO);
+		async_answer_0(chandle, EIO);
 
 	async_exch_t *exch = async_exchange_begin(sess);
-	async_forward_fast(csr->callid, exch, csr->iface, csr->arg3, 0,
+	async_forward_fast(csr->chandle, exch, csr->iface, csr->arg3, 0,
 	    IPC_FF_NONE);
 	async_exchange_end(exch);
@@ -111,5 +111,5 @@
  * @param iface   Interface to be connected to.
  * @param call    Pointer to call structure.
- * @param callid  Call ID of the request.
+ * @param chandle  Call ID of the request.
  *
  * @return Zero on success or a value from @ref errno.h.
@@ -117,5 +117,5 @@
  */
 void connect_to_clonable(service_t service, iface_t iface, ipc_call_t *call,
-    cap_call_handle_t callid)
+    cap_call_handle_t chandle)
 {
 	assert(service == SERVICE_LOADER);
@@ -123,5 +123,5 @@
 	cs_req_t *csr = malloc(sizeof(cs_req_t));
 	if (csr == NULL) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -132,5 +132,5 @@
 	if (rc != EOK) {
 		free(csr);
-		async_answer_0(callid, rc);
+		async_answer_0(chandle, rc);
 		return;
 	}
@@ -139,5 +139,5 @@
 	csr->service = service;
 	csr->iface = iface;
-	csr->callid = callid;
+	csr->chandle = chandle;
 	csr->arg3 = IPC_GET_ARG3(*call);
 
Index: uspace/srv/ns/ns.c
===================================================================
--- uspace/srv/ns/ns.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/ns/ns.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -49,8 +49,8 @@
 #include "task.h"
 
-static void ns_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void ns_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	ipc_call_t call;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	iface_t iface;
 	service_t service;
@@ -63,17 +63,17 @@
 		 */
 		if (service_clonable(service)) {
-			connect_to_clonable(service, iface, icall, iid);
+			connect_to_clonable(service, iface, icall, icall_handle);
 		} else {
-			connect_to_service(service, iface, icall, iid);
+			connect_to_service(service, iface, icall, icall_handle);
 		}
 		return;
 	}
 
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		process_pending_conn();
 
-		callid = async_get_call(&call);
+		chandle = async_get_call(&call);
 		if (!IPC_GET_IMETHOD(call))
 			break;
@@ -94,5 +94,5 @@
 			 */
 			if (service_clonable(service)) {
-				register_clonable(service, phone, &call, callid);
+				register_clonable(service, phone, &call, chandle);
 				continue;
 			} else {
@@ -107,5 +107,5 @@
 			id = (task_id_t)
 			    MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-			wait_for_task(id, &call, callid);
+			wait_for_task(id, &call, chandle);
 			continue;
 		case NS_ID_INTRO:
@@ -121,5 +121,5 @@
 		}
 
-		async_answer_0(callid, retval);
+		async_answer_0(chandle, retval);
 	}
 
Index: uspace/srv/ns/service.c
===================================================================
--- uspace/srv/ns/service.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/ns/service.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -87,8 +87,8 @@
 typedef struct {
 	link_t link;
-	service_t service;    /**< Service ID */
-	iface_t iface;        /**< Interface ID */
-	cap_call_handle_t callid;  /**< Call ID waiting for the connection */
-	sysarg_t arg3;        /**< Third argument */
+	service_t service;         /**< Service ID */
+	iface_t iface;             /**< Interface ID */
+	cap_call_handle_t chandle; /**< Call handle waiting for the connection */
+	sysarg_t arg3;             /**< Third argument */
 } pending_conn_t;
 
@@ -119,5 +119,5 @@
 		hashed_service_t *hashed_service = hash_table_get_inst(link, hashed_service_t, link);
 		async_exch_t *exch = async_exchange_begin(hashed_service->sess);
-		async_forward_fast(pending->callid, exch, pending->iface,
+		async_forward_fast(pending->chandle, exch, pending->iface,
 		    pending->arg3, 0, IPC_FF_NONE);
 		async_exchange_end(exch);
@@ -163,5 +163,5 @@
  * @param iface   Interface to be connected to.
  * @param call    Pointer to call structure.
- * @param callid  Call ID of the request.
+ * @param chandle  Call ID of the request.
  *
  * @return Zero on success or a value from @ref errno.h.
@@ -169,5 +169,5 @@
  */
 void connect_to_service(service_t service, iface_t iface, ipc_call_t *call,
-    cap_call_handle_t callid)
+    cap_call_handle_t chandle)
 {
 	sysarg_t arg3 = IPC_GET_ARG3(*call);
@@ -189,5 +189,5 @@
 			pending->service = service;
 			pending->iface = iface;
-			pending->callid = callid;
+			pending->chandle = chandle;
 			pending->arg3 = arg3;
 
@@ -202,10 +202,10 @@
 	hashed_service_t *hashed_service = hash_table_get_inst(link, hashed_service_t, link);
 	async_exch_t *exch = async_exchange_begin(hashed_service->sess);
-	async_forward_fast(callid, exch, iface, arg3, 0, IPC_FF_NONE);
+	async_forward_fast(chandle, exch, iface, arg3, 0, IPC_FF_NONE);
 	async_exchange_end(exch);
 	return;
 
 out:
-	async_answer_0(callid, retval);
+	async_answer_0(chandle, retval);
 }
 
Index: uspace/srv/ns/task.c
===================================================================
--- uspace/srv/ns/task.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/ns/task.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -146,5 +146,5 @@
 	link_t link;
 	task_id_t id;         /**< Task ID. */
-	cap_call_handle_t callid;  /**< Call ID waiting for the connection */
+	cap_call_handle_t chandle;  /**< Call ID waiting for the connection */
 } pending_wait_t;
 
@@ -184,5 +184,5 @@
 		texit = ht->have_rval ? TASK_EXIT_NORMAL :
 		    TASK_EXIT_UNEXPECTED;
-		async_answer_2(pr->callid, EOK, texit, ht->retval);
+		async_answer_2(pr->chandle, EOK, texit, ht->retval);
 
 		list_remove(&pr->link);
@@ -192,5 +192,5 @@
 }
 
-void wait_for_task(task_id_t id, ipc_call_t *call, cap_call_handle_t callid)
+void wait_for_task(task_id_t id, ipc_call_t *call, cap_call_handle_t chandle)
 {
 	ht_link_t *link = hash_table_find(&task_hash_table, &id);
@@ -200,5 +200,5 @@
 	if (ht == NULL) {
 		/* No such task exists. */
-		async_answer_0(callid, ENOENT);
+		async_answer_0(chandle, ENOENT);
 		return;
 	}
@@ -207,5 +207,5 @@
 		task_exit_t texit = ht->have_rval ? TASK_EXIT_NORMAL :
 		    TASK_EXIT_UNEXPECTED;
-		async_answer_2(callid, EOK, texit, ht->retval);
+		async_answer_2(chandle, EOK, texit, ht->retval);
 		return;
 	}
@@ -215,5 +215,5 @@
 	    (pending_wait_t *) malloc(sizeof(pending_wait_t));
 	if (!pr) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -221,5 +221,5 @@
 	link_initialize(&pr->link);
 	pr->id = id;
-	pr->callid = callid;
+	pr->chandle = chandle;
 	list_append(&pr->link, &pending_wait);
 }
Index: uspace/srv/taskmon/taskmon.c
===================================================================
--- uspace/srv/taskmon/taskmon.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/taskmon/taskmon.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -94,28 +94,28 @@
 }
 
-static void corecfg_get_enable_srv(cap_call_handle_t iid, ipc_call_t *icall)
+static void corecfg_get_enable_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
-	async_answer_1(iid, EOK, write_core_files);
+	async_answer_1(icall_handle, EOK, write_core_files);
 }
 
-static void corecfg_set_enable_srv(cap_call_handle_t iid, ipc_call_t *icall)
+static void corecfg_set_enable_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	write_core_files = IPC_GET_ARG1(*icall);
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 }
 
-static void corecfg_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void corecfg_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -123,8 +123,8 @@
 		switch (method) {
 		case CORECFG_GET_ENABLE:
-			corecfg_get_enable_srv(callid, &call);
+			corecfg_get_enable_srv(chandle, &call);
 			break;
 		case CORECFG_SET_ENABLE:
-			corecfg_set_enable_srv(callid, &call);
+			corecfg_set_enable_srv(chandle, &call);
 			break;
 		}
Index: uspace/srv/test/chardev-test/main.c
===================================================================
--- uspace/srv/test/chardev-test/main.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/test/chardev-test/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -84,5 +84,5 @@
 };
 
-static void chardev_test_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void chardev_test_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	chardev_srvs_t *svc;
@@ -97,9 +97,9 @@
 		svc = &partialx_srvs;
 	} else {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
 
-	chardev_conn(iid, icall, svc);
+	chardev_conn(icall_handle, icall, svc);
 }
 
Index: uspace/srv/vfs/vfs.c
===================================================================
--- uspace/srv/vfs/vfs.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/vfs/vfs.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -55,11 +55,11 @@
 #define NAME  "vfs"
 
-static void vfs_pager(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+static void vfs_pager(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -68,8 +68,8 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case IPC_M_PAGE_IN:
-			vfs_page_in(callid, &call);
+			vfs_page_in(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
Index: uspace/srv/vfs/vfs.h
===================================================================
--- uspace/srv/vfs/vfs.h	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/vfs/vfs.h	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -233,5 +233,5 @@
 extern errno_t vfs_rdwr_internal(int, aoff64_t, bool, rdwr_io_chunk_t *);
 
-extern void vfs_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
+extern void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
 
 #endif
Index: uspace/srv/vfs/vfs_ipc.c
===================================================================
--- uspace/srv/vfs/vfs_ipc.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/vfs/vfs_ipc.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -50,5 +50,5 @@
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
 	char *fs_name = NULL;
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	vfs_fs_probe_info_t info;
 	size_t len;
@@ -72,10 +72,10 @@
 
 	/* Now we should get a read request */
-	if (!async_data_read_receive(&callid, &len))
+	if (!async_data_read_receive(&chandle, &len))
 		goto out;
 
 	if (len > sizeof(info))
 		len = sizeof(info);
-	(void) async_data_read_finalize(callid, &info, len);
+	(void) async_data_read_finalize(chandle, &info, len);
 
 out:
@@ -85,5 +85,5 @@
 static void vfs_in_fstypes(cap_call_handle_t rid, ipc_call_t *request)
 {
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t len;
 	vfs_fstypes_t fstypes;
@@ -100,10 +100,10 @@
 
 	/* Now we should get a read request */
-	if (!async_data_read_receive(&callid, &len))
+	if (!async_data_read_receive(&chandle, &len))
 		goto out;
 
 	if (len > fstypes.size)
 		len = fstypes.size;
-	(void) async_data_read_finalize(callid, fstypes.buf, len);
+	(void) async_data_read_finalize(chandle, fstypes.buf, len);
 
 out:
@@ -315,5 +315,5 @@
 }
 
-void vfs_connection(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	bool cont = true;
@@ -323,9 +323,9 @@
 	 * This call needs to be answered.
 	 */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (cont) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -334,60 +334,60 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case VFS_IN_CLONE:
-			vfs_in_clone(callid, &call);
+			vfs_in_clone(chandle, &call);
 			break;
 		case VFS_IN_FSPROBE:
-			vfs_in_fsprobe(callid, &call);
+			vfs_in_fsprobe(chandle, &call);
 			break;
 		case VFS_IN_FSTYPES:
-			vfs_in_fstypes(callid, &call);
+			vfs_in_fstypes(chandle, &call);
 			break;
 		case VFS_IN_MOUNT:
-			vfs_in_mount(callid, &call);
+			vfs_in_mount(chandle, &call);
 			break;
 		case VFS_IN_OPEN:
-			vfs_in_open(callid, &call);
+			vfs_in_open(chandle, &call);
 			break;
 		case VFS_IN_PUT:
-			vfs_in_put(callid, &call);
+			vfs_in_put(chandle, &call);
 			break;
 		case VFS_IN_READ:
-			vfs_in_read(callid, &call);
+			vfs_in_read(chandle, &call);
 			break;
 		case VFS_IN_REGISTER:
-			vfs_register(callid, &call);
+			vfs_register(chandle, &call);
 			cont = false;
 			break;
 		case VFS_IN_RENAME:
-			vfs_in_rename(callid, &call);
+			vfs_in_rename(chandle, &call);
 			break;
 		case VFS_IN_RESIZE:
-			vfs_in_resize(callid, &call);
+			vfs_in_resize(chandle, &call);
 			break;
 		case VFS_IN_STAT:
-			vfs_in_stat(callid, &call);
+			vfs_in_stat(chandle, &call);
 			break;
 		case VFS_IN_STATFS:
-			vfs_in_statfs(callid, &call);
+			vfs_in_statfs(chandle, &call);
 			break;
 		case VFS_IN_SYNC:
-			vfs_in_sync(callid, &call);
+			vfs_in_sync(chandle, &call);
 			break;
 		case VFS_IN_UNLINK:
-			vfs_in_unlink(callid, &call);
+			vfs_in_unlink(chandle, &call);
 			break;
 		case VFS_IN_UNMOUNT:
-			vfs_in_unmount(callid, &call);
+			vfs_in_unmount(chandle, &call);
 			break;
 		case VFS_IN_WAIT_HANDLE:
-			vfs_in_wait_handle(callid, &call);
+			vfs_in_wait_handle(chandle, &call);
 			break;
 		case VFS_IN_WALK:
-			vfs_in_walk(callid, &call);
+			vfs_in_walk(chandle, &call);
 			break;
 		case VFS_IN_WRITE:
-			vfs_in_write(callid, &call);
+			vfs_in_write(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, ENOTSUP);
+			async_answer_0(chandle, ENOTSUP);
 			break;
 		}
Index: uspace/srv/vfs/vfs_register.c
===================================================================
--- uspace/srv/vfs/vfs_register.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/vfs/vfs_register.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -195,6 +195,6 @@
 
 	size_t size;
-	cap_call_handle_t callid;
-	if (!async_share_in_receive(&callid, &size)) {
+	cap_call_handle_t chandle;
+	if (!async_share_in_receive(&chandle, &size)) {
 		dprintf("Unexpected call\n");
 		list_remove(&fs_info->fs_link);
@@ -202,5 +202,5 @@
 		async_hangup(fs_info->sess);
 		free(fs_info);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		async_answer_0(rid, EINVAL);
 		return;
@@ -216,5 +216,5 @@
 		async_hangup(fs_info->sess);
 		free(fs_info);
-		async_answer_0(callid, EINVAL);
+		async_answer_0(chandle, EINVAL);
 		async_answer_0(rid, EINVAL);
 		return;
@@ -224,5 +224,5 @@
 	 * Commit to read-only sharing the PLB with the client.
 	 */
-	(void) async_share_in_finalize(callid, plb,
+	(void) async_share_in_finalize(chandle, plb,
 	    AS_AREA_READ | AS_AREA_CACHEABLE);
 
Index: uspace/srv/volsrv/volsrv.c
===================================================================
--- uspace/srv/volsrv/volsrv.c	(revision 3e242d25d5b49481f9f26ba4a66712daa6a48540)
+++ uspace/srv/volsrv/volsrv.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -85,14 +85,14 @@
 }
 
-static void vol_get_parts_srv(cap_call_handle_t iid, ipc_call_t *icall)
-{
-	cap_call_handle_t callid;
+static void vol_get_parts_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
+{
+	cap_call_handle_t chandle;
 	size_t size;
 	size_t act_size;
 	errno_t rc;
 
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
@@ -100,6 +100,6 @@
 	service_id_t *id_buf = (service_id_t *) malloc(size);
 	if (id_buf == NULL) {
-		async_answer_0(callid, ENOMEM);
-		async_answer_0(iid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
+		async_answer_0(icall_handle, ENOMEM);
 		return;
 	}
@@ -107,16 +107,16 @@
 	rc = vol_part_get_ids(id_buf, size, &act_size);
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	errno_t retval = async_data_read_finalize(callid, id_buf, size);
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	errno_t retval = async_data_read_finalize(chandle, id_buf, size);
 	free(id_buf);
 
-	async_answer_1(iid, retval, act_size);
-}
-
-static void vol_part_add_srv(cap_call_handle_t iid, ipc_call_t *icall)
+	async_answer_1(icall_handle, retval, act_size);
+}
+
+static void vol_part_add_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -127,12 +127,12 @@
 	rc = vol_part_add(sid);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-static void vol_part_info_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vol_part_info_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -146,5 +146,5 @@
 	rc = vol_part_find_by_id(sid, &part);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -152,34 +152,34 @@
 	rc = vol_part_get_info(part, &pinfo);
 	if (rc != EOK) {
-		async_answer_0(iid, EIO);
-		return;
-	}
-
-	cap_call_handle_t callid;
+		async_answer_0(icall_handle, EIO);
+		return;
+	}
+
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(vol_part_info_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &pinfo,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &pinfo,
 	    min(size, sizeof(pinfo)));
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-static void vol_part_empty_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vol_part_empty_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -192,5 +192,5 @@
 	rc = vol_part_find_by_id(sid, &part);
 	if (rc != EOK) {
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -198,12 +198,12 @@
 	rc = vol_part_empty_part(part);
 	if (rc != EOK) {
-		async_answer_0(iid, EIO);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-static void vol_part_get_lsupp_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(icall_handle, EIO);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vol_part_get_lsupp_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	vol_fstype_t fstype;
@@ -217,31 +217,31 @@
 	volsrv_part_get_lsupp(fstype, &vlsupp);
 
-	cap_call_handle_t callid;
+	cap_call_handle_t chandle;
 	size_t size;
-	if (!async_data_read_receive(&callid, &size)) {
-		async_answer_0(callid, EREFUSED);
-		async_answer_0(iid, EREFUSED);
+	if (!async_data_read_receive(&chandle, &size)) {
+		async_answer_0(chandle, EREFUSED);
+		async_answer_0(icall_handle, EREFUSED);
 		return;
 	}
 
 	if (size != sizeof(vol_label_supp_t)) {
-		async_answer_0(callid, EINVAL);
-		async_answer_0(iid, EINVAL);
-		return;
-	}
-
-	rc = async_data_read_finalize(callid, &vlsupp,
+		async_answer_0(chandle, EINVAL);
+		async_answer_0(icall_handle, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(chandle, &vlsupp,
 	    min(size, sizeof(vlsupp)));
 	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		async_answer_0(iid, rc);
-		return;
-	}
-
-	async_answer_0(iid, EOK);
-}
-
-
-static void vol_part_mkfs_srv(cap_call_handle_t iid, ipc_call_t *icall)
+		async_answer_0(chandle, rc);
+		async_answer_0(icall_handle, rc);
+		return;
+	}
+
+	async_answer_0(icall_handle, EOK);
+}
+
+
+static void vol_part_mkfs_srv(cap_call_handle_t icall_handle, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -257,5 +257,5 @@
 	    0, NULL);
 	if (rc != EOK) {
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
@@ -267,5 +267,5 @@
 	if (rc != EOK) {
 		free(label);
-		async_answer_0(iid, ENOENT);
+		async_answer_0(icall_handle, ENOENT);
 		return;
 	}
@@ -274,27 +274,27 @@
 	if (rc != EOK) {
 		free(label);
-		async_answer_0(iid, rc);
+		async_answer_0(icall_handle, rc);
 		return;
 	}
 
 	free(label);
-	async_answer_0(iid, EOK);
-}
-
-static void vol_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
+	async_answer_0(icall_handle, EOK);
+}
+
+static void vol_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_client_conn()");
 
 	/* Accept the connection */
-	async_answer_0(iid, EOK);
+	async_answer_0(icall_handle, EOK);
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t callid = async_get_call(&call);
+		cap_call_handle_t chandle = async_get_call(&call);
 		sysarg_t method = IPC_GET_IMETHOD(call);
 
 		if (!method) {
 			/* The other side has hung up */
-			async_answer_0(callid, EOK);
+			async_answer_0(chandle, EOK);
 			return;
 		}
@@ -302,23 +302,23 @@
 		switch (method) {
 		case VOL_GET_PARTS:
-			vol_get_parts_srv(callid, &call);
+			vol_get_parts_srv(chandle, &call);
 			break;
 		case VOL_PART_ADD:
-			vol_part_add_srv(callid, &call);
+			vol_part_add_srv(chandle, &call);
 			break;
 		case VOL_PART_INFO:
-			vol_part_info_srv(callid, &call);
+			vol_part_info_srv(chandle, &call);
 			break;
 		case VOL_PART_EMPTY:
-			vol_part_empty_srv(callid, &call);
+			vol_part_empty_srv(chandle, &call);
 			break;
 		case VOL_PART_LSUPP:
-			vol_part_get_lsupp_srv(callid, &call);
+			vol_part_get_lsupp_srv(chandle, &call);
 			break;
 		case VOL_PART_MKFS:
-			vol_part_mkfs_srv(callid, &call);
+			vol_part_mkfs_srv(chandle, &call);
 			break;
 		default:
-			async_answer_0(callid, EINVAL);
+			async_answer_0(chandle, EINVAL);
 		}
 	}
