Index: uspace/lib/drv/generic/remote_nic.c
===================================================================
--- uspace/lib/drv/generic/remote_nic.c	(revision 3bacee1839e6f355100ab4ea86bb211e9ecf19ed)
+++ uspace/lib/drv/generic/remote_nic.c	(revision 984a9ba2fa05c490a7066737655ed19130c714e8)
@@ -1337,5 +1337,5 @@
 
 static void remote_nic_send_frame(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    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(chandle, EINVAL);
+		async_answer_0(call, EINVAL);
 		return;
 	}
 
 	rc = nic_iface->send_frame(dev, data, size);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 	free(data);
 }
 
 static void remote_nic_callback_create(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    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(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_get_state(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    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(chandle, rc, state);
+	async_answer_1(call, rc, state);
 }
 
 static void remote_nic_set_state(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    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(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_get_address(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1402,49 +1402,49 @@
 	errno_t rc = nic_iface->get_address(dev, &address);
 	if (rc == EOK) {
+		ipc_call_t data;
 		size_t max_len;
-		cap_call_handle_t data_chandle;
 
 		/* All errors will be translated into EPARTY anyway */
-		if (!async_data_read_receive(&data_chandle, &max_len)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_read_receive(&data, &max_len)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (max_len != sizeof(nic_address_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_chandle, &address,
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(&data, &address,
 		    sizeof(nic_address_t));
 	}
 
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_set_address(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
-{
-	nic_iface_t *nic_iface = (nic_iface_t *) iface;
-
+    ipc_call_t *call)
+{
+	nic_iface_t *nic_iface = (nic_iface_t *) iface;
+
+	ipc_call_t data;
 	size_t length;
-	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);
+	if (!async_data_write_receive(&data, &length)) {
+		async_answer_0(&data, EINVAL);
+		async_answer_0(call, EINVAL);
 		return;
 	}
 
 	if (length > sizeof(nic_address_t)) {
-		async_answer_0(data_chandle, ELIMIT);
-		async_answer_0(chandle, ELIMIT);
+		async_answer_0(&data, ELIMIT);
+		async_answer_0(call, ELIMIT);
 		return;
 	}
 
 	nic_address_t address;
-	if (async_data_write_finalize(data_chandle, &address, length) != EOK) {
-		async_answer_0(chandle, EINVAL);
+	if (async_data_write_finalize(&data, &address, length) != EOK) {
+		async_answer_0(call, EINVAL);
 		return;
 	}
@@ -1452,15 +1452,15 @@
 	if (nic_iface->set_address != NULL) {
 		errno_t rc = nic_iface->set_address(dev, &address);
-		async_answer_0(chandle, rc);
+		async_answer_0(call, rc);
 	} else
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 }
 
 static void remote_nic_get_stats(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_stats == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1471,31 +1471,31 @@
 	errno_t rc = nic_iface->get_stats(dev, &stats);
 	if (rc == EOK) {
-		cap_call_handle_t data_chandle;
+		ipc_call_t data;
 		size_t max_len;
-		if (!async_data_read_receive(&data_chandle, &max_len)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_read_receive(&data, &max_len)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (max_len < sizeof(nic_device_stats_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_chandle, &stats,
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(&data, &stats,
 		    sizeof(nic_device_stats_t));
 	}
 
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_get_device_info(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_device_info == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1506,31 +1506,31 @@
 	errno_t rc = nic_iface->get_device_info(dev, &info);
 	if (rc == EOK) {
-		cap_call_handle_t data_chandle;
+		ipc_call_t data;
 		size_t max_len;
-		if (!async_data_read_receive(&data_chandle, &max_len)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_read_receive(&data, &max_len)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (max_len < sizeof (nic_device_info_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_chandle, &info,
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(&data, &info,
 		    sizeof(nic_device_info_t));
 	}
 
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_get_cable_state(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_cable_state == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1539,13 +1539,13 @@
 
 	errno_t rc = nic_iface->get_cable_state(dev, &cs);
-	async_answer_1(chandle, rc, (sysarg_t) cs);
+	async_answer_1(call, rc, (sysarg_t) cs);
 }
 
 static void remote_nic_get_operation_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_operation_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1556,14 +1556,14 @@
 
 	errno_t rc = nic_iface->get_operation_mode(dev, &speed, &duplex, &role);
-	async_answer_3(chandle, rc, (sysarg_t) speed, (sysarg_t) duplex,
+	async_answer_3(call, 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 chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->set_operation_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1574,13 +1574,13 @@
 
 	errno_t rc = nic_iface->set_operation_mode(dev, speed, duplex, role);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_autoneg_enable(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_enable == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1589,26 +1589,26 @@
 
 	errno_t rc = nic_iface->autoneg_enable(dev, advertisement);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_autoneg_disable(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_disable == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = nic_iface->autoneg_disable(dev);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_autoneg_probe(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_probe == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1621,27 +1621,27 @@
 	errno_t rc = nic_iface->autoneg_probe(dev, &our_adv, &their_adv, &result,
 	    &their_result);
-	async_answer_4(chandle, rc, our_adv, their_adv, (sysarg_t) result,
+	async_answer_4(call, 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 chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->autoneg_restart == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = nic_iface->autoneg_restart(dev);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_get_pause(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->get_pause == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1652,13 +1652,13 @@
 
 	errno_t rc = nic_iface->get_pause(dev, &we_send, &we_receive, &pause);
-	async_answer_3(chandle, rc, we_send, we_receive, pause);
+	async_answer_3(call, rc, we_send, we_receive, pause);
 }
 
 static void remote_nic_set_pause(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->set_pause == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1670,13 +1670,13 @@
 	errno_t rc = nic_iface->set_pause(dev, allow_send, allow_receive,
 	    pause);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_unicast_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->unicast_get_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1688,5 +1688,5 @@
 		address_list = malloc(max_count * sizeof (nic_address_t));
 		if (!address_list) {
-			async_answer_0(chandle, ENOMEM);
+			async_answer_0(call, ENOMEM);
 			return;
 		}
@@ -1702,13 +1702,13 @@
 	if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
 		free(address_list);
-		async_answer_2(chandle, rc, mode, address_count);
-		return;
-	}
-
-	cap_call_handle_t data_chandle;
+		async_answer_2(call, rc, mode, address_count);
+		return;
+	}
+
+	ipc_call_t data;
 	size_t max_len;
-	if (!async_data_read_receive(&data_chandle, &max_len)) {
-		async_answer_0(data_chandle, EINVAL);
-		async_answer_2(chandle, rc, mode, address_count);
+	if (!async_data_read_receive(&data, &max_len)) {
+		async_answer_0(&data, EINVAL);
+		async_answer_2(call, rc, mode, address_count);
 		free(address_list);
 		return;
@@ -1721,13 +1721,12 @@
 		max_len = max_count * sizeof(nic_address_t);
 
-	async_data_read_finalize(data_chandle, address_list, max_len);
-	async_answer_0(data_chandle, EINVAL);
+	async_data_read_finalize(&data, address_list, max_len);
 
 	free(address_list);
-	async_answer_2(chandle, rc, mode, address_count);
+	async_answer_2(call, rc, mode, address_count);
 }
 
 static void remote_nic_unicast_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1739,14 +1738,14 @@
 
 	if (address_count) {
-		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);
+		ipc_call_t data;
+		if (!async_data_write_receive(&data, &length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (length != address_count * sizeof(nic_address_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
 			return;
 		}
@@ -1754,12 +1753,12 @@
 		address_list = malloc(length);
 		if (address_list == NULL) {
-			async_answer_0(data_chandle, ENOMEM);
-			async_answer_0(chandle, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_chandle, address_list,
+			async_answer_0(&data, ENOMEM);
+			async_answer_0(call, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(&data, address_list,
 		    length) != EOK) {
-			async_answer_0(chandle, EINVAL);
+			async_answer_0(call, EINVAL);
 			free(address_list);
 			return;
@@ -1770,7 +1769,7 @@
 		errno_t rc = nic_iface->unicast_set_mode(dev, mode, address_list,
 		    address_count);
-		async_answer_0(chandle, rc);
+		async_answer_0(call, rc);
 	} else
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 
 	free(address_list);
@@ -1778,9 +1777,9 @@
 
 static void remote_nic_multicast_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->multicast_get_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1792,5 +1791,5 @@
 		address_list = malloc(max_count * sizeof(nic_address_t));
 		if (!address_list) {
-			async_answer_0(chandle, ENOMEM);
+			async_answer_0(call, ENOMEM);
 			return;
 		}
@@ -1807,13 +1806,13 @@
 	if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
 		free(address_list);
-		async_answer_2(chandle, rc, mode, address_count);
-		return;
-	}
-
-	cap_call_handle_t data_chandle;
+		async_answer_2(call, rc, mode, address_count);
+		return;
+	}
+
+	ipc_call_t data;
 	size_t max_len;
-	if (!async_data_read_receive(&data_chandle, &max_len)) {
-		async_answer_0(data_chandle, EINVAL);
-		async_answer_2(chandle, rc, mode, address_count);
+	if (!async_data_read_receive(&data, &max_len)) {
+		async_answer_0(&data, EINVAL);
+		async_answer_2(call, rc, mode, address_count);
 		free(address_list);
 		return;
@@ -1826,12 +1825,12 @@
 		max_len = max_count * sizeof(nic_address_t);
 
-	async_data_read_finalize(data_chandle, address_list, max_len);
+	async_data_read_finalize(&data, address_list, max_len);
 
 	free(address_list);
-	async_answer_2(chandle, rc, mode, address_count);
+	async_answer_2(call, rc, mode, address_count);
 }
 
 static void remote_nic_multicast_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -1842,15 +1841,15 @@
 
 	if (address_count) {
-		cap_call_handle_t data_chandle;
+		ipc_call_t data;
 		size_t length;
-		if (!async_data_write_receive(&data_chandle, &length)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_write_receive(&data, &length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (length != address_count * sizeof (nic_address_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
 			return;
 		}
@@ -1858,12 +1857,12 @@
 		address_list = malloc(length);
 		if (address_list == NULL) {
-			async_answer_0(data_chandle, ENOMEM);
-			async_answer_0(chandle, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_chandle, address_list,
+			async_answer_0(&data, ENOMEM);
+			async_answer_0(call, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(&data, address_list,
 		    length) != EOK) {
-			async_answer_0(chandle, EINVAL);
+			async_answer_0(call, EINVAL);
 			free(address_list);
 			return;
@@ -1874,7 +1873,7 @@
 		errno_t rc = nic_iface->multicast_set_mode(dev, mode, address_list,
 		    address_count);
-		async_answer_0(chandle, rc);
+		async_answer_0(call, rc);
 	} else
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 
 	free(address_list);
@@ -1882,9 +1881,9 @@
 
 static void remote_nic_broadcast_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->broadcast_get_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1893,13 +1892,13 @@
 
 	errno_t rc = nic_iface->broadcast_get_mode(dev, &mode);
-	async_answer_1(chandle, rc, mode);
+	async_answer_1(call, rc, mode);
 }
 
 static void remote_nic_broadcast_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->broadcast_set_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1908,13 +1907,13 @@
 
 	errno_t rc = nic_iface->broadcast_set_mode(dev, mode);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_defective_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->defective_get_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1923,13 +1922,13 @@
 
 	errno_t rc = nic_iface->defective_get_mode(dev, &mode);
-	async_answer_1(chandle, rc, mode);
+	async_answer_1(call, rc, mode);
 }
 
 static void remote_nic_defective_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->defective_set_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1938,13 +1937,13 @@
 
 	errno_t rc = nic_iface->defective_set_mode(dev, mode);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_blocked_sources_get(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->blocked_sources_get == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -1956,5 +1955,5 @@
 		address_list = malloc(max_count * sizeof(nic_address_t));
 		if (!address_list) {
-			async_answer_0(chandle, ENOMEM);
+			async_answer_0(call, ENOMEM);
 			return;
 		}
@@ -1968,14 +1967,14 @@
 
 	if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
-		async_answer_1(chandle, rc, address_count);
+		async_answer_1(call, rc, address_count);
 		free(address_list);
 		return;
 	}
 
-	cap_call_handle_t data_chandle;
+	ipc_call_t data;
 	size_t max_len;
-	if (!async_data_read_receive(&data_chandle, &max_len)) {
-		async_answer_0(data_chandle, EINVAL);
-		async_answer_1(chandle, rc, address_count);
+	if (!async_data_read_receive(&data, &max_len)) {
+		async_answer_0(&data, EINVAL);
+		async_answer_1(call, rc, address_count);
 		free(address_list);
 		return;
@@ -1988,13 +1987,12 @@
 		max_len = max_count * sizeof(nic_address_t);
 
-	async_data_read_finalize(data_chandle, address_list, max_len);
-	async_answer_0(data_chandle, EINVAL);
+	async_data_read_finalize(&data, address_list, max_len);
 
 	free(address_list);
-	async_answer_1(chandle, rc, address_count);
+	async_answer_1(call, rc, address_count);
 }
 
 static void remote_nic_blocked_sources_set(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -2005,14 +2003,14 @@
 
 	if (address_count) {
-		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);
+		ipc_call_t data;
+		if (!async_data_write_receive(&data, &length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (length != address_count * sizeof(nic_address_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
 			return;
 		}
@@ -2020,12 +2018,12 @@
 		address_list = malloc(length);
 		if (address_list == NULL) {
-			async_answer_0(data_chandle, ENOMEM);
-			async_answer_0(chandle, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_chandle, address_list,
+			async_answer_0(&data, ENOMEM);
+			async_answer_0(call, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(&data, address_list,
 		    length) != EOK) {
-			async_answer_0(chandle, EINVAL);
+			async_answer_0(call, EINVAL);
 			free(address_list);
 			return;
@@ -2036,7 +2034,7 @@
 		errno_t rc = nic_iface->blocked_sources_set(dev, address_list,
 		    address_count);
-		async_answer_0(chandle, rc);
+		async_answer_0(call, rc);
 	} else
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 
 	free(address_list);
@@ -2044,9 +2042,9 @@
 
 static void remote_nic_vlan_get_mask(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->vlan_get_mask == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2057,26 +2055,26 @@
 	errno_t rc = nic_iface->vlan_get_mask(dev, &vlan_mask);
 	if (rc == EOK) {
-		cap_call_handle_t data_chandle;
+		ipc_call_t data;
 		size_t max_len;
-		if (!async_data_read_receive(&data_chandle, &max_len)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_read_receive(&data, &max_len)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (max_len != sizeof(nic_vlan_mask_t)) {
-			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);
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
+			return;
+		}
+
+		async_data_read_finalize(&data, &vlan_mask, max_len);
+	}
+
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_vlan_set_mask(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -2087,21 +2085,21 @@
 
 	if (vlan_mask_set) {
-		cap_call_handle_t data_chandle;
+		ipc_call_t data;
 		size_t length;
-		if (!async_data_write_receive(&data_chandle, &length)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_write_receive(&data, &length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (length != sizeof(nic_vlan_mask_t)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
-			return;
-		}
-
-		if (async_data_write_finalize(data_chandle, &vlan_mask,
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
+			return;
+		}
+
+		if (async_data_write_finalize(&data, &vlan_mask,
 		    length) != EOK) {
-			async_answer_0(chandle, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
@@ -2112,16 +2110,16 @@
 	if (nic_iface->vlan_set_mask != NULL) {
 		errno_t rc = nic_iface->vlan_set_mask(dev, vlan_mask_pointer);
-		async_answer_0(chandle, rc);
+		async_answer_0(call, rc);
 	} else
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 }
 
 static void remote_nic_vlan_set_tag(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	if (nic_iface->vlan_set_tag == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2132,45 +2130,45 @@
 
 	errno_t rc = nic_iface->vlan_set_tag(dev, tag, add, strip);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_wol_virtue_add(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    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_chandle;
+	ipc_call_t data;
 
 	if (nic_iface->wol_virtue_add == NULL) {
 		if (send_data) {
-			async_data_write_receive(&data_chandle, NULL);
-			async_answer_0(data_chandle, ENOTSUP);
-		}
-
-		async_answer_0(chandle, ENOTSUP);
+			async_data_write_receive(&data, NULL);
+			async_answer_0(&data, ENOTSUP);
+		}
+
+		async_answer_0(call, ENOTSUP);
 	}
 
 	size_t length = 0;
-	void *data = NULL;
+	void *virtue = NULL;
 
 	if (send_data) {
-		if (!async_data_write_receive(&data_chandle, &length)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
-			return;
-		}
-
-		data = malloc(length);
-		if (data == NULL) {
-			async_answer_0(data_chandle, ENOMEM);
-			async_answer_0(chandle, ENOMEM);
-			return;
-		}
-
-		if (async_data_write_finalize(data_chandle, data,
+		if (!async_data_write_receive(&data, &length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
+			return;
+		}
+
+		virtue = malloc(length);
+		if (virtue == NULL) {
+			async_answer_0(&data, ENOMEM);
+			async_answer_0(call, ENOMEM);
+			return;
+		}
+
+		if (async_data_write_finalize(&data, virtue,
 		    length) != EOK) {
-			async_answer_0(chandle, EINVAL);
-			free(data);
+			async_answer_0(call, EINVAL);
+			free(virtue);
 			return;
 		}
@@ -2180,16 +2178,16 @@
 	nic_wv_type_t type = (nic_wv_type_t) IPC_GET_ARG2(*call);
 
-	errno_t rc = nic_iface->wol_virtue_add(dev, type, data, length, &id);
-	async_answer_1(chandle, rc, (sysarg_t) id);
-	free(data);
+	errno_t rc = nic_iface->wol_virtue_add(dev, type, virtue, length, &id);
+	async_answer_1(call, rc, (sysarg_t) id);
+	free(virtue);
 }
 
 static void remote_nic_wol_virtue_remove(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	if (nic_iface->wol_virtue_remove == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2198,14 +2196,14 @@
 
 	errno_t rc = nic_iface->wol_virtue_remove(dev, id);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_wol_virtue_probe(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 
 	if (nic_iface->wol_virtue_probe == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2215,26 +2213,26 @@
 	nic_wv_type_t type = NIC_WV_NONE;
 	size_t length = 0;
-	cap_call_handle_t data_chandle;
-	void *data = NULL;
+	ipc_call_t data;
+	void *virtue = NULL;
 
 	if (max_length != 0) {
-		data = malloc(max_length);
-		if (data == NULL) {
-			async_answer_0(chandle, ENOMEM);
-			return;
-		}
-	}
-
-	memset(data, 0, max_length);
+		virtue = malloc(max_length);
+		if (virtue == NULL) {
+			async_answer_0(call, ENOMEM);
+			return;
+		}
+	}
+
+	memset(virtue, 0, max_length);
 
 	errno_t rc = nic_iface->wol_virtue_probe(dev, id, &type, max_length,
-	    data, &length);
+	    virtue, &length);
 
 	if ((max_length != 0) && (length != 0)) {
 		size_t req_length;
-		if (!async_data_read_receive(&data_chandle, &req_length)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
-			free(data);
+		if (!async_data_read_receive(&data, &req_length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
+			free(virtue);
 			return;
 		}
@@ -2246,17 +2244,17 @@
 			req_length = max_length;
 
-		async_data_read_finalize(data_chandle, data, req_length);
-	}
-
-	async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) length);
-	free(data);
+		async_data_read_finalize(&data, virtue, req_length);
+	}
+
+	async_answer_2(call, rc, (sysarg_t) type, (sysarg_t) length);
+	free(virtue);
 }
 
 static void remote_nic_wol_virtue_list(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->wol_virtue_list == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2266,10 +2264,10 @@
 	size_t count = 0;
 	nic_wv_id_t *id_list = NULL;
-	cap_call_handle_t data_chandle;
+	ipc_call_t data;
 
 	if (max_count != 0) {
 		id_list = malloc(max_count * sizeof(nic_wv_id_t));
 		if (id_list == NULL) {
-			async_answer_0(chandle, ENOMEM);
+			async_answer_0(call, ENOMEM);
 			return;
 		}
@@ -2283,7 +2281,7 @@
 	if ((max_count != 0) && (count != 0)) {
 		size_t req_length;
-		if (!async_data_read_receive(&data_chandle, &req_length)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
+		if (!async_data_read_receive(&data, &req_length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			free(id_list);
 			return;
@@ -2296,17 +2294,17 @@
 			req_length = max_count * sizeof(nic_wv_id_t);
 
-		rc = async_data_read_finalize(data_chandle, id_list, req_length);
-	}
-
-	async_answer_1(chandle, rc, (sysarg_t) count);
+		rc = async_data_read_finalize(&data, id_list, req_length);
+	}
+
+	async_answer_1(call, 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 chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->wol_virtue_get_caps == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2316,13 +2314,13 @@
 
 	errno_t rc = nic_iface->wol_virtue_get_caps(dev, type, &count);
-	async_answer_1(chandle, rc, (sysarg_t) count);
+	async_answer_1(call, rc, (sysarg_t) count);
 }
 
 static void remote_nic_wol_load_info(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->wol_load_info == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2331,25 +2329,25 @@
 	size_t frame_length = 0;
 	nic_wv_type_t type = NIC_WV_NONE;
-	uint8_t *data = NULL;
+	uint8_t *info = NULL;
 
 	if (max_length != 0) {
-		data = malloc(max_length);
-		if (data == NULL) {
-			async_answer_0(chandle, ENOMEM);
-			return;
-		}
-	}
-
-	memset(data, 0, max_length);
-
-	errno_t rc = nic_iface->wol_load_info(dev, &type, max_length, data,
+		info = malloc(max_length);
+		if (info == NULL) {
+			async_answer_0(call, ENOMEM);
+			return;
+		}
+	}
+
+	memset(info, 0, max_length);
+
+	errno_t rc = nic_iface->wol_load_info(dev, &type, max_length, info,
 	    &frame_length);
 	if (rc == EOK) {
-		cap_call_handle_t data_chandle;
+		ipc_call_t data;
 		size_t req_length;
-		if (!async_data_read_receive(&data_chandle, &req_length)) {
-			async_answer_0(data_chandle, EINVAL);
-			async_answer_0(chandle, EINVAL);
-			free(data);
+		if (!async_data_read_receive(&data, &req_length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
+			free(info);
 			return;
 		}
@@ -2357,17 +2355,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_chandle, data, req_length);
-	}
-
-	async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) frame_length);
-	free(data);
+		async_data_read_finalize(&data, info, req_length);
+	}
+
+	async_answer_2(call, rc, (sysarg_t) type, (sysarg_t) frame_length);
+	free(info);
 }
 
 static void remote_nic_offload_probe(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->offload_probe == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2377,13 +2375,13 @@
 
 	errno_t rc = nic_iface->offload_probe(dev, &supported, &active);
-	async_answer_2(chandle, rc, supported, active);
+	async_answer_2(call, rc, supported, active);
 }
 
 static void remote_nic_offload_set(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->offload_set == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2393,13 +2391,13 @@
 
 	errno_t rc = nic_iface->offload_set(dev, mask, active);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
 static void remote_nic_poll_get_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->poll_get_mode == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
@@ -2414,28 +2412,28 @@
 	errno_t rc = nic_iface->poll_get_mode(dev, &mode, &period);
 	if ((rc == EOK) && (request_data)) {
+		ipc_call_t data;
 		size_t max_len;
-		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);
+
+		if (!async_data_read_receive(&data, &max_len)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (max_len != sizeof(struct timeval)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
-			return;
-		}
-
-		async_data_read_finalize(data_chandle, &period,
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
+			return;
+		}
+
+		async_data_read_finalize(&data, &period,
 		    sizeof(struct timeval));
 	}
 
-	async_answer_1(chandle, rc, (sysarg_t) mode);
+	async_answer_1(call, rc, (sysarg_t) mode);
 }
 
 static void remote_nic_poll_set_mode(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
@@ -2448,21 +2446,21 @@
 
 	if (has_period) {
-		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);
+		ipc_call_t data;
+		if (!async_data_write_receive(&data, &length)) {
+			async_answer_0(&data, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
 
 		if (length != sizeof(struct timeval)) {
-			async_answer_0(data_chandle, ELIMIT);
-			async_answer_0(chandle, ELIMIT);
+			async_answer_0(&data, ELIMIT);
+			async_answer_0(call, ELIMIT);
 			return;
 		}
 
 		period = &period_buf;
-		if (async_data_write_finalize(data_chandle, period,
+		if (async_data_write_finalize(&data, period,
 		    length) != EOK) {
-			async_answer_0(chandle, EINVAL);
+			async_answer_0(call, EINVAL);
 			return;
 		}
@@ -2471,20 +2469,20 @@
 	if (nic_iface->poll_set_mode != NULL) {
 		errno_t rc = nic_iface->poll_set_mode(dev, mode, period);
-		async_answer_0(chandle, rc);
+		async_answer_0(call, rc);
 	} else
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 }
 
 static void remote_nic_poll_now(ddf_fun_t *dev, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
 	nic_iface_t *nic_iface = (nic_iface_t *) iface;
 	if (nic_iface->poll_now == NULL) {
-		async_answer_0(chandle, ENOTSUP);
+		async_answer_0(call, ENOTSUP);
 		return;
 	}
 
 	errno_t rc = nic_iface->poll_now(dev);
-	async_answer_0(chandle, rc);
+	async_answer_0(call, rc);
 }
 
