cleanup vbox code

1 files changed, 174 insertions, 237 deletions

diff --git a/vboxshfl.h b/vboxshfl.h
index 36cd818..9be37c8 100644
--- a/vboxshfl.h
+++ b/vboxshfl.h
@@ -69,457 +69,394 @@ static void shflstring_strncpy(SHFLSTRING *str, const char __far *src, unsigned
 	str->ach[str->u16Length] = '\0';
 }
 
-static int32_t vbox_shfl_query_mappings(LPVBOXCOMM vb, hgcm_client_id_t client_id, uint32_t flags, unsigned __far *num_maps, SHFLMAPPING __far *maps)
+static inline void vbox_hgcm_set_parameter_shflroot(VMMDevHGCMCall __far *req, unsigned arg, SHFLROOT root)
 {
-	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
-	vbox_hgcm_init_call(req, client_id, SHFL_FN_QUERY_MAPPINGS, 3);
+	vbox_hgcm_set_parameter_uint32(req, arg, root);
+}
 
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = flags;
+static inline void vbox_hgcm_set_parameter_shflhandle(VMMDevHGCMCall __far *req, unsigned arg, SHFLHANDLE handle)
+{
+	vbox_hgcm_set_parameter_uint64(req, arg, handle);
+}
 
-	req->aParms[1].type = VMMDevHGCMParmType_32bit;
-	req->aParms[1].u.value32 = *num_maps;
+static void vbox_hgcm_set_parameter_shflstring(VMMDevHGCMCall __far *req, unsigned arg, const SHFLSTRING *str)
+{
+	vbox_hgcm_set_parameter_pointer(req, arg, shflstring_size_with_buf(str), str);
+}
+
+static vboxerr vbox_shfl_query_mappings(LPVBOXCOMM vb, hgcm_client_id_t client_id, uint32_t flags, unsigned __far *num_maps, SHFLMAPPING __far *maps)
+{
+	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
 
-	req->aParms[2].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[2].u.Pointer.size = sizeof(SHFLMAPPING) * *num_maps;
-	req->aParms[2].u.Pointer.u.linearAddr = linear_addr(maps);
+	vbox_hgcm_init_call(req, client_id, SHFL_FN_QUERY_MAPPINGS, 3);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	vbox_hgcm_set_parameter_uint32(req, 0, flags);
+	vbox_hgcm_set_parameter_uint32(req, 1, *num_maps);
+	vbox_hgcm_set_parameter_pointer(req, 2, sizeof(SHFLMAPPING) * *num_maps, maps);
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
-	*num_maps = req->aParms[1].u.value32;
+	*num_maps = vbox_hgcm_get_parameter_uint32(req, 1);
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_query_map_name(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLSTRING *name)
+static vboxerr vbox_shfl_query_map_name(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLSTRING *name)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
-	vbox_hgcm_init_call(req, client_id, SHFL_FN_QUERY_MAP_NAME, 2);
-
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vboxerr err;
 
-	req->aParms[1].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[1].u.Pointer.size = shflstring_size_with_buf(name);
-	req->aParms[1].u.Pointer.u.linearAddr = linear_addr(name);
+	vbox_hgcm_init_call(req, client_id, SHFL_FN_QUERY_MAP_NAME, 2);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
+	vbox_hgcm_set_parameter_shflstring(req, 1, name);
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_map_folder(LPVBOXCOMM vb, hgcm_client_id_t client_id, const SHFLSTRING *name, SHFLROOT *root)
+static vboxerr vbox_shfl_map_folder(LPVBOXCOMM vb, hgcm_client_id_t client_id, const SHFLSTRING *name, SHFLROOT *root)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_MAP_FOLDER, 4);
 
 	// arg 0 in shflstring "name"
-	req->aParms[0].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[0].u.Pointer.size = shflstring_size_with_buf(name);
-	req->aParms[0].u.Pointer.u.linearAddr = linear_addr(name);
+	vbox_hgcm_set_parameter_pointer(req, 0, shflstring_size_with_buf(name), name);
 
 	// arg 1 out uint32 "root"
-	req->aParms[1].type = VMMDevHGCMParmType_32bit;
-	req->aParms[1].u.value32 = *root;
+	vbox_hgcm_set_parameter_uint32(req, 1, 0);
 
 	// arg 2 in uint32 "delimiter"
-	req->aParms[2].type = VMMDevHGCMParmType_32bit;
-	req->aParms[2].u.value32 = '\\';
+	vbox_hgcm_set_parameter_uint32(req, 2, '\\');
 
 	// arg 3 in uint32 "caseSensitive"
-	req->aParms[3].type = VMMDevHGCMParmType_32bit;
-	req->aParms[3].u.value32 = 0;
+	vbox_hgcm_set_parameter_uint32(req, 3, 0);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
-
-	*root = req->aParms[1].u.value32;
+	*root = vbox_hgcm_get_parameter_uint32(req, 1);
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_unmap_folder(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root)
+static vboxerr vbox_shfl_unmap_folder(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_UNMAP_FOLDER, 1);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if (err = vbox_hgcm_do_call_sync(vb, req))
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_open(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, const SHFLSTRING *name, SHFLCREATEPARMS *parms)
+static vboxerr vbox_shfl_open(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, const SHFLSTRING *name, SHFLCREATEPARMS *parms)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_CREATE, 3);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in shflstring "name"
-	req->aParms[1].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[1].u.Pointer.size = shflstring_size_with_buf(name);
-	req->aParms[1].u.Pointer.u.linearAddr = linear_addr(name);
+	vbox_hgcm_set_parameter_shflstring(req, 1, name);
 
 	// arg 2 in shflcreateparms "parms"
-	req->aParms[2].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[2].u.Pointer.size = sizeof(SHFLCREATEPARMS);
-	req->aParms[2].u.Pointer.u.linearAddr = linear_addr(parms);
+	vbox_hgcm_set_parameter_pointer(req, 2, sizeof(SHFLCREATEPARMS), parms);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_close(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle)
+static vboxerr vbox_shfl_close(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_CLOSE, 2);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in uint64 "handle"
-	req->aParms[1].type = VMMDevHGCMParmType_64bit;
-	req->aParms[1].u.value64 = handle;
+	vbox_hgcm_set_parameter_shflhandle(req, 1, handle);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_read(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
+static vboxerr vbox_shfl_read(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
                                unsigned long offset, unsigned __far *size, void __far *buffer)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_READ, 5);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in uint64 "handle"
-	req->aParms[1].type = VMMDevHGCMParmType_64bit;
-	req->aParms[1].u.value64 = handle;
+	vbox_hgcm_set_parameter_shflhandle(req, 1, handle);
 
 	// arg 2 in uint64 "offset"
-	req->aParms[2].type = VMMDevHGCMParmType_64bit;
-	req->aParms[2].u.value64 = offset;
+	vbox_hgcm_set_parameter_uint64(req, 2, offset);
 
 	// arg 3 inout uint32 "size"
-	req->aParms[3].type = VMMDevHGCMParmType_32bit;
-	req->aParms[3].u.value32 = *size;
+	vbox_hgcm_set_parameter_uint32(req, 3, *size);
 
 	// arg 4 out void "buffer"
-	req->aParms[4].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[4].u.Pointer.size = *size;
-	req->aParms[4].u.Pointer.u.linearAddr = linear_addr(buffer);
+	vbox_hgcm_set_parameter_pointer(req, 4, *size, buffer);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
-	*size = req->aParms[3].u.value32;
+	*size = vbox_hgcm_get_parameter_uint32(req, 3);
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_write(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
+static vboxerr vbox_shfl_write(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
                                unsigned long offset, unsigned __far *size, void __far *buffer)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_WRITE, 5);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in uint64 "handle"
-	req->aParms[1].type = VMMDevHGCMParmType_64bit;
-	req->aParms[1].u.value64 = handle;
+	vbox_hgcm_set_parameter_shflhandle(req, 1, handle);
 
 	// arg 2 in uint64 "offset"
-	req->aParms[2].type = VMMDevHGCMParmType_64bit;
-	req->aParms[2].u.value64 = offset;
+	vbox_hgcm_set_parameter_uint64(req, 2, offset);
 
 	// arg 3 inout uint32 "size"
-	req->aParms[3].type = VMMDevHGCMParmType_32bit;
-	req->aParms[3].u.value32 = *size;
+	vbox_hgcm_set_parameter_uint32(req, 3, *size);
 
 	// arg 4 in void "buffer"
-	req->aParms[4].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[4].u.Pointer.size = *size;
-	req->aParms[4].u.Pointer.u.linearAddr = linear_addr(buffer);
-
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	vbox_hgcm_set_parameter_pointer(req, 4, *size, buffer);
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
-	*size = req->aParms[3].u.value32;
+	*size = vbox_hgcm_get_parameter_uint32(req, 3);
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_lock(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
+static vboxerr vbox_shfl_lock(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
                               unsigned long offset, unsigned long length, unsigned flags)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_LOCK, 5);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in uint64 "handle"
-	req->aParms[1].type = VMMDevHGCMParmType_64bit;
-	req->aParms[1].u.value64 = handle;
+	vbox_hgcm_set_parameter_shflhandle(req, 1, handle);
 
 	// arg 2 in uint64 "offset"
-	req->aParms[2].type = VMMDevHGCMParmType_64bit;
-	req->aParms[2].u.value64 = offset;
+	vbox_hgcm_set_parameter_uint64(req, 2, offset);
 
-	// arg 3 inout uint64 "length"
-	req->aParms[3].type = VMMDevHGCMParmType_64bit;
-	req->aParms[3].u.value64 = length;
+	// arg 3 in uint64 "length"
+	vbox_hgcm_set_parameter_uint64(req, 3, length);
 
 	// arg 4 in uint32 "flags"
-	req->aParms[4].type = VMMDevHGCMParmType_32bit;
-	req->aParms[4].u.value32 = flags;
+	vbox_hgcm_set_parameter_uint32(req, 4, flags);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_list(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
+static vboxerr vbox_shfl_list(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
                               unsigned flags, unsigned __far *size, const SHFLSTRING *path, SHFLDIRINFO *dirinfo, unsigned __far *resume, unsigned __far *count)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_LIST, 8);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in uint64 "handle"
-	req->aParms[1].type = VMMDevHGCMParmType_64bit;
-	req->aParms[1].u.value64 = handle;
+	vbox_hgcm_set_parameter_shflhandle(req, 1, handle);
 
 	// arg 2 in uint32 "flags"
-	req->aParms[2].type = VMMDevHGCMParmType_32bit;
-	req->aParms[2].u.value32 = flags;
+	vbox_hgcm_set_parameter_uint32(req, 2, flags);
 
 	// arg 3 inout uint32 "size"
-	req->aParms[3].type = VMMDevHGCMParmType_32bit;
-	req->aParms[3].u.value32 = *size;
+	vbox_hgcm_set_parameter_uint32(req, 3, *size);
 
 	// arg 4 in shflstring "path"
-	req->aParms[4].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[4].u.Pointer.size = shflstring_size_optional_in(path);
-	req->aParms[4].u.Pointer.u.linearAddr = linear_addr(path);
+	vbox_hgcm_set_parameter_pointer(req, 4, shflstring_size_optional_in(path), path);
 
 	// arg 5 out void "dirinfo"
-	req->aParms[5].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[5].u.Pointer.size = *size;
-	req->aParms[5].u.Pointer.u.linearAddr = linear_addr(dirinfo);
+	vbox_hgcm_set_parameter_pointer(req, 5, *size, dirinfo);
 
 	// arg 6 inout uint32 "resume_point"
-	req->aParms[6].type = VMMDevHGCMParmType_32bit;
-	req->aParms[6].u.value32 = *resume;
+	vbox_hgcm_set_parameter_uint32(req, 6, *resume);
 
 	// arg 7 out uint32 "count"
-	req->aParms[7].type = VMMDevHGCMParmType_32bit;
-	req->aParms[7].u.value32 = 0;
+	vbox_hgcm_set_parameter_uint32(req, 7, 0);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	*size = vbox_hgcm_get_parameter_uint32(req, 3);
+	*resume = vbox_hgcm_get_parameter_uint32(req, 6);
+	*count = vbox_hgcm_get_parameter_uint32(req, 7);
+
+	return req->header.result;
+}
+
+static vboxerr vbox_shfl_info(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root, SHFLHANDLE handle,
+                               unsigned flags, unsigned __far *size, void __far *buffer)
+{
+	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
+	vbox_hgcm_init_call(req, client_id, SHFL_FN_INFORMATION, 5);
+
+	// arg 0 in uint32 "root"
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
+
+	// arg 1 in uint64 "handle"
+	vbox_hgcm_set_parameter_shflhandle(req, 1, handle);
+
+	// arg 2 in uint32 "flags"
+	vbox_hgcm_set_parameter_uint32(req, 2, flags);
 
-	*size = req->aParms[3].u.value32;
-	*resume = req->aParms[6].u.value32;
-	*count = req->aParms[7].u.value32;
+	// arg 3 inout uint32 "size"
+	vbox_hgcm_set_parameter_uint32(req, 3, *size);
+
+	// arg 4 in void "buffer"
+	vbox_hgcm_set_parameter_pointer(req, 4, *size, buffer);
+
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
+
+	*size = vbox_hgcm_get_parameter_uint32(req, 3);
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_remove(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root,
+static vboxerr vbox_shfl_remove(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root,
                                 const SHFLSTRING *path, unsigned flags)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_REMOVE, 3);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in shflstring "path"
-	req->aParms[1].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[1].u.Pointer.size = shflstring_size_with_buf(path);
-	req->aParms[1].u.Pointer.u.linearAddr = linear_addr(path);
+	vbox_hgcm_set_parameter_shflstring(req, 1, path);
 
 	// arg 2 in uint32 "flags"
-	req->aParms[2].type = VMMDevHGCMParmType_32bit;
-	req->aParms[2].u.value32 = flags;
-
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	vbox_hgcm_set_parameter_uint32(req, 2, flags);
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_rename(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root,
+static vboxerr vbox_shfl_rename(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root,
                                 const SHFLSTRING *src, const SHFLSTRING *dst, unsigned flags)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_RENAME, 4);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 in shflstring "src"
-	req->aParms[1].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[1].u.Pointer.size = shflstring_size_with_buf(src);
-	req->aParms[1].u.Pointer.u.linearAddr = linear_addr(src);
+	vbox_hgcm_set_parameter_shflstring(req, 1, src);
 
 	// arg 2 in shflstring "dst"
-	req->aParms[2].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[2].u.Pointer.size = shflstring_size_with_buf(dst);
-	req->aParms[2].u.Pointer.u.linearAddr = linear_addr(dst);
+	vbox_hgcm_set_parameter_shflstring(req, 2, dst);
 
 	// arg 3 in uint32 "flags"
-	req->aParms[3].type = VMMDevHGCMParmType_32bit;
-	req->aParms[3].u.value32 = flags;
+	vbox_hgcm_set_parameter_uint32(req, 3, flags);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_set_utf8(LPVBOXCOMM vb, hgcm_client_id_t client_id)
+static vboxerr vbox_shfl_set_utf8(LPVBOXCOMM vb, hgcm_client_id_t client_id)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
-	vbox_hgcm_init_call(req, client_id, SHFL_FN_SET_UTF8, 0);
+	vboxerr err;
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
+	vbox_hgcm_init_call(req, client_id, SHFL_FN_SET_UTF8, 0);
 
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
 	return req->header.result;
 }
 
-static int32_t vbox_shfl_query_map_info(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root,
+static vboxerr vbox_shfl_query_map_info(LPVBOXCOMM vb, hgcm_client_id_t client_id, SHFLROOT root,
                                         SHFLSTRING *name, SHFLSTRING *mountPoint, unsigned *flags, unsigned *version)
 {
 	VMMDevHGCMCall __far *req = (void __far *) vb->buf;
+	vboxerr err;
+
 	vbox_hgcm_init_call(req, client_id, SHFL_FN_QUERY_MAP_INFO, 5);
 
 	// arg 0 in uint32 "root"
-	req->aParms[0].type = VMMDevHGCMParmType_32bit;
-	req->aParms[0].u.value32 = root;
+	vbox_hgcm_set_parameter_shflroot(req, 0, root);
 
 	// arg 1 inout shflstring "name"
-	req->aParms[1].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[1].u.Pointer.size = shflstring_size_with_buf(name);
-	req->aParms[1].u.Pointer.u.linearAddr = linear_addr(name);
+	vbox_hgcm_set_parameter_shflstring(req, 1, name);
 
 	// arg 2 inout shflstring "mountPoint"
-	req->aParms[2].type = VMMDevHGCMParmType_LinAddr;
-	req->aParms[2].u.Pointer.size = shflstring_size_with_buf(mountPoint);
-	req->aParms[2].u.Pointer.u.linearAddr = linear_addr(mountPoint);
+	vbox_hgcm_set_parameter_shflstring(req, 2, mountPoint);
 
 	// arg 3 inout uint64 "flags"
-	req->aParms[3].type = VMMDevHGCMParmType_64bit;
-	req->aParms[3].u.value64 = *flags;
+	vbox_hgcm_set_parameter_uint64(req, 3, *flags);
 
 	// arg 4 out uint32 "version"
-	req->aParms[4].type = VMMDevHGCMParmType_32bit;
-	req->aParms[4].u.value32 = *version;
+	vbox_hgcm_set_parameter_uint32(req, 4, 0);
 
-	vbox_send_request(vb->iobase, vb->dds.physicalAddress);
-
-	if (req->header.header.rc < 0) {
-		return req->header.header.rc;
-	} else if (req->header.header.rc == VINF_HGCM_ASYNC_EXECUTE) {
-		vbox_hgcm_wait(&req->header);
-	}
+	if ((err = vbox_hgcm_do_call_sync(vb, req)) < 0)
+		return err;
 
-	*flags = req->aParms[3].u.value64;
-	*version = req->aParms[4].u.value32;
+	*flags = vbox_hgcm_get_parameter_uint64(req, 3);
+	*version = vbox_hgcm_get_parameter_uint32(req, 4);
 
 	return req->header.result;
 }