自学教程：C++ svc_plugin_send函数代码示例

void guac_rdpdr_fs_process_close(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id) {    wStream* output_stream;    guac_rdp_fs_file* file;    guac_client_log(device->rdpdr->client, GUAC_LOG_DEBUG,            "%s: [file_id=%i]",            __func__, file_id);    /* Get file */    file = guac_rdp_fs_get_file((guac_rdp_fs*) device->data, file_id);    if (file == NULL)        return;    /* If file was written to, and it's in the /Download folder, start stream */    if (file->bytes_written > 0 &&            strncmp(file->absolute_path, "//Download//", 10) == 0) {        guac_rdpdr_start_download(device, file->absolute_path);        guac_rdp_fs_delete((guac_rdp_fs*) device->data, file_id);    }    /* Close file */    guac_rdp_fs_close((guac_rdp_fs*) device->data, file_id);    output_stream = guac_rdpdr_new_io_completion(device, completion_id,            STATUS_SUCCESS, 4);    Stream_Write(output_stream, "/0/0/0/0", 4); /* Padding */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpdr_fs_process_query_basic_info(guac_rdpdr_device* device, wStream* input_stream,        int file_id, int completion_id) {    wStream* output_stream;    guac_rdp_fs_file* file;    /* Get file */    file = guac_rdp_fs_get_file((guac_rdp_fs*) device->data, file_id);    if (file == NULL)        return;    GUAC_RDP_DEBUG(2, "[file_id=%i]", file_id);    output_stream = guac_rdpdr_new_io_completion(device, completion_id,            STATUS_SUCCESS, 40);    Stream_Write_UINT32(output_stream, 36);    Stream_Write_UINT64(output_stream, file->ctime);      /* CreationTime   */    Stream_Write_UINT64(output_stream, file->atime);      /* LastAccessTime */    Stream_Write_UINT64(output_stream, file->mtime);      /* LastWriteTime  */    Stream_Write_UINT64(output_stream, file->mtime);      /* ChangeTime     */    Stream_Write_UINT32(output_stream, file->attributes); /* FileAttributes */    /* Reserved field must not be sent */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpdr_fs_process_query_attribute_tag_info(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id) {    wStream* output_stream;    guac_rdp_fs_file* file;    /* Get file */    file = guac_rdp_fs_get_file((guac_rdp_fs*) device->data, file_id);    if (file == NULL)        return;    GUAC_RDP_DEBUG(2, "[file_id=%i]", file_id);    output_stream = guac_rdpdr_new_io_completion(device, completion_id,            STATUS_SUCCESS, 12);    Stream_Write_UINT32(output_stream, 8);    Stream_Write_UINT32(output_stream, file->attributes); /* FileAttributes */    Stream_Write_UINT32(output_stream, 0);                /* ReparseTag */    /* Reserved field must not be sent */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

static int drdynvc_process_close_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s){	UINT32 ChannelId;	wStream* data_out;	int value;	int error;	ChannelId = drdynvc_read_variable_uint(s, cbChId);	DEBUG_DVC("ChannelId=%d", ChannelId);	dvcman_close_channel(drdynvc->channel_mgr, ChannelId);		data_out = Stream_New(NULL, 4);	value = (CLOSE_REQUEST_PDU << 4) | (cbChId & 0x03);	Stream_Write_UINT8(data_out, value);	drdynvc_write_variable_uint(data_out, ChannelId);	error = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);		if (error != CHANNEL_RC_OK)	{		DEBUG_WARN("VirtualChannelWrite failed %d", error);		return 1;	}		drdynvc->channel_error = error;	return 0;}

/* server is getting a feel of the round trip time */void guac_rdpsnd_training_handler(guac_rdpsndPlugin* rdpsnd,        wStream* input_stream, guac_rdpsnd_pdu_header* header) {    int data_size;    wStream* output_stream;    /* Get associated client data */    guac_client* client = rdpsnd->client;    guac_rdp_client* rdp_client = (guac_rdp_client*) client->data;    /* Read timestamp and data size */    Stream_Read_UINT16(input_stream, rdpsnd->server_timestamp);    Stream_Read_UINT16(input_stream, data_size);    /* Send training response */    output_stream = Stream_New(NULL, 8);    Stream_Write_UINT8(output_stream, SNDC_TRAINING);    Stream_Write_UINT8(output_stream, 0);    Stream_Write_UINT16(output_stream, 4);    Stream_Write_UINT16(output_stream, rdpsnd->server_timestamp);    Stream_Write_UINT16(output_stream, data_size);    pthread_mutex_lock(&(rdp_client->rdp_lock));    svc_plugin_send((rdpSvcPlugin*) rdpsnd, output_stream);    pthread_mutex_unlock(&(rdp_client->rdp_lock));}

void guac_rdpdr_fs_process_query_standard_info(guac_rdpdr_device* device, wStream* input_stream,        int file_id, int completion_id) {    wStream* output_stream;    guac_rdp_fs_file* file;    BOOL is_directory = FALSE;    /* Get file */    file = guac_rdp_fs_get_file((guac_rdp_fs*) device->data, file_id);    if (file == NULL)        return;    GUAC_RDP_DEBUG(2, "[file_id=%i]", file_id);    if (file->attributes & FILE_ATTRIBUTE_DIRECTORY)        is_directory = TRUE;    output_stream = guac_rdpdr_new_io_completion(device, completion_id,            STATUS_SUCCESS, 26);    Stream_Write_UINT32(output_stream, 22);    Stream_Write_UINT64(output_stream, file->size);   /* AllocationSize */    Stream_Write_UINT64(output_stream, file->size);   /* EndOfFile      */    Stream_Write_UINT32(output_stream, 1);            /* NumberOfLinks  */    Stream_Write_UINT8(output_stream,  0);            /* DeletePending  */    Stream_Write_UINT8(output_stream,  is_directory); /* Directory      */    /* Reserved field must not be sent */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpdr_process_print_job_close(guac_rdpdr_device* device,        wStream* input_stream, int completion_id) {    guac_rdpdr_printer_data* printer_data =        (guac_rdpdr_printer_data*) device->data;    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_SUCCESS, 1);    Stream_Write_UINT32(output_stream, 0); /* padding*/    /* Close input and wait for output thread to finish */    close(printer_data->printer_input);    pthread_join(printer_data->printer_output_thread, NULL);    /* Close file descriptors */    close(printer_data->printer_output);    /* Close file */    guac_client_log(device->rdpdr->client, GUAC_LOG_INFO, "Print job closed");    guac_protocol_send_end(device->rdpdr->client->socket, printer_data->stream);    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

static int drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s){	wStream* data_out;	int error;	DEBUG_DVC("Sp=%d cbChId=%d", Sp, cbChId);	Stream_Seek(s, 1); /* pad */	Stream_Read_UINT16(s, drdynvc->version);	/* RDP8 servers offer version 3, though Microsoft forgot to document it	 * in their early documents.  It behaves the same as version 2.	 */	if ((drdynvc->version == 2) || (drdynvc->version == 3))	{		Stream_Read_UINT16(s, drdynvc->PriorityCharge0);		Stream_Read_UINT16(s, drdynvc->PriorityCharge1);		Stream_Read_UINT16(s, drdynvc->PriorityCharge2);		Stream_Read_UINT16(s, drdynvc->PriorityCharge3);	}	data_out = Stream_New(NULL, 4);	Stream_Write_UINT16(data_out, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */	Stream_Write_UINT16(data_out, drdynvc->version);	error = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);	if (error != CHANNEL_RC_OK)	{		DEBUG_WARN("VirtualChannelWrite failed %d", error);		return 1;	}	drdynvc->channel_error = error;	return 0;}

static void sample_process_receive(rdpSvcPlugin* plugin, STREAM* data_in){	int bytes;	STREAM* data_out;	samplePlugin* sample = (samplePlugin*) plugin;	printf("sample_process_receive:/n");	if (!sample)	{		printf("sample_process_receive: sample is nil/n");		return;	}	/* process data in (from server) here */	/* here we just send the same data back */	bytes = stream_get_size(data_in);	printf("sample_process_receive: got bytes %d/n", bytes);	if (bytes > 0)	{		data_out = stream_new(bytes);		stream_copy(data_out, data_in, bytes);		/* svc_plugin_send takes ownership of data_out, that is why		   we do not free it */		bytes = stream_get_length(data_in);		printf("sample_process_receive: sending bytes %d/n", bytes);		svc_plugin_send(plugin, data_out);	}	stream_free(data_in);}

static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr){	STREAM* data_out;	size_t computerNameLenW;	UNICONV* uniconv;	char* s;	uniconv = freerdp_uniconv_new();	if (!rdpdr->computerName[0])		gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);	s = freerdp_uniconv_out(uniconv, rdpdr->computerName, &computerNameLenW);	data_out = stream_new(16 + computerNameLenW + 2);	stream_write_uint16(data_out, RDPDR_CTYP_CORE);	stream_write_uint16(data_out, PAKID_CORE_CLIENT_NAME);	stream_write_uint32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */	stream_write_uint32(data_out, 0); /* codePage, must be set to zero */	stream_write_uint32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */	stream_write(data_out, s, computerNameLenW);	stream_write_uint16(data_out, 0); /* null terminator */	xfree(s);	freerdp_uniconv_free(uniconv);	svc_plugin_send((rdpSvcPlugin*)rdpdr, data_out);}

static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr){	STREAM* data_out;	WCHAR* computerNameW = NULL;	size_t computerNameLenW;	if (!rdpdr->computerName[0])		gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);	computerNameLenW = ConvertToUnicode(CP_UTF8, 0, rdpdr->computerName, -1, &computerNameW, 0) * 2;	data_out = stream_new(16 + computerNameLenW + 2);	stream_write_UINT16(data_out, RDPDR_CTYP_CORE);	stream_write_UINT16(data_out, PAKID_CORE_CLIENT_NAME);	stream_write_UINT32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */	stream_write_UINT32(data_out, 0); /* codePage, must be set to zero */	stream_write_UINT32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */	stream_write(data_out, computerNameW, computerNameLenW);	stream_write_UINT16(data_out, 0); /* null terminator */	free(computerNameW);	svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);}

void guac_rdpdr_fs_process_set_end_of_file_info(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id, int length) {    int result;    UINT64 size;    wStream* output_stream;    /* Read new size */    Stream_Read_UINT64(input_stream, size); /* AllocationSize */    GUAC_RDP_DEBUG(2, "[file_id=%i] size=%" PRIu64, file_id, (uint64_t) size);    /* Truncate file */    result = guac_rdp_fs_truncate((guac_rdp_fs*) device->data, file_id, size);    if (result < 0)        output_stream = guac_rdpdr_new_io_completion(device,                completion_id, guac_rdp_fs_get_status(result), 4);    else        output_stream = guac_rdpdr_new_io_completion(device,                completion_id, STATUS_SUCCESS, 4);    Stream_Write_UINT32(output_stream, length);    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

static int drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* data_in){	STREAM* data_out;	int error;	DEBUG_DVC("Sp=%d cbChId=%d", Sp, cbChId);	stream_seek(data_in, 1); /* pad */	stream_read_uint16(data_in, drdynvc->version);	if (drdynvc->version == 2)	{		stream_read_uint16(data_in, drdynvc->PriorityCharge0);		stream_read_uint16(data_in, drdynvc->PriorityCharge1);		stream_read_uint16(data_in, drdynvc->PriorityCharge2);		stream_read_uint16(data_in, drdynvc->PriorityCharge3);	}	data_out = stream_new(4);	stream_write_uint16(data_out, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */	stream_write_uint16(data_out, drdynvc->version);	error = svc_plugin_send((rdpSvcPlugin*)drdynvc, data_out);	if (error != CHANNEL_RC_OK)	{		DEBUG_WARN("VirtualChannelWrite failed %d", error);		return 1;	}	return 0;}

static int drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s){	int pos;	int status;	UINT32 ChannelId;	wStream* data_out;	int channel_status;	if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)	{		/**		 * For some reason the server does not always send the		 * capabilities pdu as it should. When this happens,		 * send a capabilities response.		 */		drdynvc->version = 3;		drdynvc_send_capability_response(drdynvc);		drdynvc->state = DRDYNVC_STATE_READY;	}	ChannelId = drdynvc_read_variable_uint(s, cbChId);	pos = Stream_GetPosition(s);	DEBUG_DVC("ChannelId=%d ChannelName=%s", ChannelId, Stream_Pointer(s));	channel_status = dvcman_create_channel(drdynvc->channel_mgr, ChannelId, (char*) Stream_Pointer(s));	data_out = Stream_New(NULL, pos + 4);	Stream_Write_UINT8(data_out, 0x10 | cbChId);	Stream_SetPosition(s, 1);	Stream_Copy(data_out, s, pos - 1);		if (channel_status == 0)	{		DEBUG_DVC("channel created");		Stream_Write_UINT32(data_out, 0);	}	else	{		DEBUG_DVC("no listener");		Stream_Write_UINT32(data_out, (UINT32)(-1));	}	status = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);	if (status != CHANNEL_RC_OK)	{		DEBUG_WARN("VirtualChannelWrite failed %d", status);		return 1;	}	if (channel_status == 0)	{		dvcman_open_channel(drdynvc->channel_mgr, ChannelId);	}	return 0;}

void rail_send_channel_data(void* rail_object, void* data, size_t length){	wStream* s = NULL;	railPlugin* plugin = (railPlugin*) rail_object;	s = Stream_New(NULL, length);	Stream_Write(s, data, length);	svc_plugin_send((rdpSvcPlugin*) plugin, s);}

void rail_send_channel_data(void* rail_object, void* data, size_t length){	STREAM* s = NULL;	railPlugin* plugin = (railPlugin*) rail_object;	s = stream_new(length);	stream_write(s, data, length);	svc_plugin_send((rdpSvcPlugin*) plugin, s);}

void guac_rdpdr_fs_process_set_rename_info(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id, int length) {    int result;    int filename_length;    wStream* output_stream;    char destination_path[GUAC_RDP_FS_MAX_PATH];    /* Read structure */    Stream_Seek_UINT8(input_stream); /* ReplaceIfExists */    Stream_Seek_UINT8(input_stream); /* RootDirectory */    Stream_Read_UINT32(input_stream, filename_length); /* FileNameLength */    /* Convert name to UTF-8 */    guac_rdp_utf16_to_utf8(Stream_Pointer(input_stream), filename_length/2,            destination_path, sizeof(destination_path));    GUAC_RDP_DEBUG(2, "[file_id=%i] destination_path=/"%s/"", file_id, destination_path);    /* If file moving to /Download folder, start stream, do not move */    if (strncmp(destination_path, "//Download//", 10) == 0) {        guac_rdp_fs_file* file;        /* Get file */        file = guac_rdp_fs_get_file((guac_rdp_fs*) device->data, file_id);        if (file == NULL)            return;        /* Initiate download, pretend move succeeded */        guac_rdpdr_start_download(device, file->absolute_path);        output_stream = guac_rdpdr_new_io_completion(device,                completion_id, STATUS_SUCCESS, 4);    }    /* Otherwise, rename as requested */    else {        result = guac_rdp_fs_rename((guac_rdp_fs*) device->data, file_id,                destination_path);        if (result < 0)            output_stream = guac_rdpdr_new_io_completion(device,                    completion_id, guac_rdp_fs_get_status(result), 4);        else            output_stream = guac_rdpdr_new_io_completion(device,                    completion_id, STATUS_SUCCESS, 4);    }    Stream_Write_UINT32(output_stream, length);    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

static void rdpdbg_process_receive(rdpSvcPlugin* plugin, STREAM* data_in){	STREAM* data_out;	DEBUG_WARN("size %d", stream_get_size(data_in));	stream_free(data_in);	data_out = stream_new(8);	stream_write(data_out, "senddata", 8);	svc_plugin_send(plugin, data_out);}

void guac_rdpdr_fs_process_set_volume_info(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id) {    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_NOT_SUPPORTED, 0);    guac_client_log(device->rdpdr->client, GUAC_LOG_DEBUG,            "%s: [file_id=%i] Set volume info not supported",            __func__, file_id);    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void cliprdr_packet_send(cliprdrPlugin* cliprdr, STREAM* s){	int pos;	uint32 dataLen;	pos = stream_get_pos(s);	dataLen = pos - 8;	stream_set_pos(s, 4);	stream_write_uint32(s, dataLen);	stream_set_pos(s, pos);	svc_plugin_send((rdpSvcPlugin*) cliprdr, s);}

void guac_rdpdr_fs_process_set_basic_info(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id, int length) {    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_SUCCESS, 4);    /* Currently do nothing, just respond */    Stream_Write_UINT32(output_stream, length);    GUAC_RDP_DEBUG(2, "[file_id=%i] IGNORED", file_id);    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void cliprdr_packet_send(cliprdrPlugin* cliprdr, wStream* s){	int pos;	UINT32 dataLen;	pos = Stream_GetPosition(s);	dataLen = pos - 8;	Stream_SetPosition(s, 4);	Stream_Write_UINT32(s, dataLen);	Stream_SetPosition(s, pos);#ifdef WITH_DEBUG_CLIPRDR	WLog_DBG(TAG, "Cliprdr Sending (%d bytes)", dataLen + 8);	winpr_HexDump(TAG, WLOG_DEBUG, Stream_Buffer(s), dataLen + 8);#endif	svc_plugin_send((rdpSvcPlugin*) cliprdr, s);}

static void rdpdr_send_client_announce_reply(rdpdrPlugin* rdpdr){	STREAM* data_out;	data_out = stream_new(12);	stream_write_UINT16(data_out, RDPDR_CTYP_CORE);	stream_write_UINT16(data_out, PAKID_CORE_CLIENTID_CONFIRM);	stream_write_UINT16(data_out, rdpdr->versionMajor);	stream_write_UINT16(data_out, rdpdr->versionMinor);	stream_write_UINT32(data_out, (UINT32) rdpdr->clientID);	svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);}

void guac_rdpdr_fs_process_lock_control(guac_rdpdr_device* device, wStream* input_stream,        int file_id, int completion_id) {    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_NOT_SUPPORTED, 5);    guac_client_log(device->rdpdr->client, GUAC_LOG_DEBUG,            "%s: [file_id=%i] Lock not supported",            __func__, file_id);    Stream_Zero(output_stream, 5); /* Padding */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpdr_fs_process_query_device_info(guac_rdpdr_device* device, wStream* input_stream,        int file_id, int completion_id) {    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_SUCCESS, 12);    GUAC_RDP_DEBUG(2, "[file_id=%i]", file_id);    Stream_Write_UINT32(output_stream, 8);    Stream_Write_UINT32(output_stream, FILE_DEVICE_DISK); /* DeviceType */    Stream_Write_UINT32(output_stream, 0); /* Characteristics */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpdr_fs_process_read(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id) {    UINT32 length;    UINT64 offset;    char* buffer;    int bytes_read;    wStream* output_stream;    /* Read packet */    Stream_Read_UINT32(input_stream, length);    Stream_Read_UINT64(input_stream, offset);    guac_client_log(device->rdpdr->client, GUAC_LOG_DEBUG,            "%s: [file_id=%i] length=%i, offset=%" PRIu64,             __func__, file_id, length, (uint64_t) offset);    /* Ensure buffer size does not exceed a safe maximum */    if (length > GUAC_RDP_MAX_READ_BUFFER)        length = GUAC_RDP_MAX_READ_BUFFER;    /* Allocate buffer */    buffer = malloc(length);    /* Attempt read */    bytes_read = guac_rdp_fs_read((guac_rdp_fs*) device->data, file_id, offset,            buffer, length);    /* If error, return invalid parameter */    if (bytes_read < 0) {        output_stream = guac_rdpdr_new_io_completion(device, completion_id,                guac_rdp_fs_get_status(bytes_read), 4);        Stream_Write_UINT32(output_stream, 0); /* Length */    }    /* Otherwise, send bytes read */    else {        output_stream = guac_rdpdr_new_io_completion(device, completion_id,                STATUS_SUCCESS, 4+bytes_read);        Stream_Write_UINT32(output_stream, bytes_read);  /* Length */        Stream_Write(output_stream, buffer, bytes_read); /* ReadData */    }    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);    free(buffer);}

static void irp_complete(IRP* irp){	int pos;	DEBUG_SVC("DeviceId %d FileId %d CompletionId %d", irp->device->id, irp->FileId, irp->CompletionId);	pos = stream_get_pos(irp->output);	stream_set_pos(irp->output, 12);	stream_write_uint32(irp->output, irp->IoStatus);	stream_set_pos(irp->output, pos);	svc_plugin_send(irp->devman->plugin, irp->output);	irp->output = NULL;	irp_free(irp);}

void guac_rdpdr_fs_process_device_control(guac_rdpdr_device* device,        wStream* input_stream, int file_id, int completion_id) {    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_INVALID_PARAMETER, 4);    guac_client_log(device->rdpdr->client, GUAC_LOG_DEBUG,            "%s: [file_id=%i] IGNORED",            __func__, file_id);    /* No content for now */    Stream_Write_UINT32(output_stream, 0);    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpdr_process_print_job_create(guac_rdpdr_device* device,        wStream* input_stream, int completion_id) {    guac_rdpdr_printer_data* printer_data =        (guac_rdpdr_printer_data*) device->data;    wStream* output_stream = guac_rdpdr_new_io_completion(device,            completion_id, STATUS_SUCCESS, 4);    /* No bytes received yet */    printer_data->bytes_received = 0;    Stream_Write_UINT32(output_stream, 0); /* fileId */    svc_plugin_send((rdpSvcPlugin*) device->rdpdr, output_stream);}

void guac_rdpsnd_wave_handler(guac_rdpsndPlugin* rdpsnd,        wStream* input_stream, guac_rdpsnd_pdu_header* header) {    rdpSvcPlugin* plugin = (rdpSvcPlugin*)rdpsnd;    /* Get associated client data */    guac_client* client = rdpsnd->client;    guac_rdp_client* rdp_client = (guac_rdp_client*) client->data;    /* Get audio stream from client data */    guac_audio_stream* audio = rdp_client->audio;    /* Wave Confirmation PDU */    wStream* output_stream = Stream_New(NULL, 8);    /* Get wave data */    unsigned char* buffer = Stream_Buffer(input_stream);    /* Copy over first four bytes */    memcpy(buffer, rdpsnd->initial_wave_data, 4);    /* Write rest of audio packet */    if (audio != NULL) {        guac_audio_stream_write_pcm(audio, buffer,                rdpsnd->incoming_wave_size + 4);        guac_audio_stream_flush(audio);    }    /* Write Wave Confirmation PDU */    Stream_Write_UINT8(output_stream, SNDC_WAVECONFIRM);    Stream_Write_UINT8(output_stream, 0);    Stream_Write_UINT16(output_stream, 4);    Stream_Write_UINT16(output_stream, rdpsnd->server_timestamp);    Stream_Write_UINT8(output_stream, rdpsnd->waveinfo_block_number);    Stream_Write_UINT8(output_stream, 0);    /* Send Wave Confirmation PDU */    pthread_mutex_lock(&(rdp_client->rdp_lock));    svc_plugin_send(plugin, output_stream);    pthread_mutex_unlock(&(rdp_client->rdp_lock));    /* We no longer expect to receive wave data */    rdpsnd->next_pdu_is_wave = FALSE;}