uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity

chanarv: x prefix for stream functions to avoid name collision

Browse Source
ulab-next
Jay Sorg 11 years ago
parent 64fabbad68
commit e4b19abd1d
2 changed files with 177 additions and 177 deletions
Show Stats Download Patch File Download Diff File

4
sesman/chansrv/chansrv_fuse.c
Unescape View File

@ -1942,7 +1942,7 @@ void xfuse_devredir_cb_file_close(void *vp)
xinode->nopen--; xinode->nopen--;
if ((xinode->nopen == 0) && fip->fi && fip->fi->fh) if ((xinode->nopen == 0) && fip->fi && fip->fi->fh)
free((char *) fip->fi->fh); free((char *) (tintptr) (fip->fi->fh));
fuse_reply_err(fip->req, 0); fuse_reply_err(fip->req, 0);
} }
@ -2645,7 +2645,7 @@ static void xfuse_cb_flush(fuse_req_t req, fuse_ino_t ino, struct
fuse_file_info *fi) fuse_file_info *fi)
{ {
XFUSE_INFO *fip = NULL; XFUSE_INFO *fip = NULL;
XFUSE_HANDLE *handle = (XFUSE_HANDLE *) fi->fh; XFUSE_HANDLE *handle = (XFUSE_HANDLE *) (tintptr) (fi->fh);
if (!xfuse_is_inode_valid(ino)) if (!xfuse_is_inode_valid(ino))
{ {

350
sesman/chansrv/devredir.c
Unescape View File

@ -83,20 +83,20 @@ dev_redir_init(void)
} }
/* setup stream */ /* setup stream */
stream_new(s, 1024); xstream_new(s, 1024);
/* initiate drive redirection protocol by sending Server Announce Req */ /* initiate drive redirection protocol by sending Server Announce Req */
stream_wr_u16_le(s, RDPDR_CTYP_CORE); xstream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_SERVER_ANNOUNCE); xstream_wr_u16_le(s, PAKID_CORE_SERVER_ANNOUNCE);
stream_wr_u16_le(s, 0x0001); /* server major ver */ xstream_wr_u16_le(s, 0x0001); /* server major ver */
stream_wr_u16_le(s, 0x000C); /* server minor ver - pretend 2 b Win 7 */ xstream_wr_u16_le(s, 0x000C); /* server minor ver - pretend 2 b Win 7 */
stream_wr_u32_le(s, u.clientID); /* unique ClientID */ xstream_wr_u32_le(s, u.clientID); /* unique ClientID */
/* send data to client */ /* send data to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return 0; return 0;
} }
@ -135,9 +135,9 @@ dev_redir_data_in(struct stream *s, int chan_id, int chan_flags, int length,
{ {
/* is this is the first packet? */ /* is this is the first packet? */
if (chan_flags & 1) if (chan_flags & 1)
stream_new(g_input_stream, total_length); xstream_new(g_input_stream, total_length);
stream_copyin(g_input_stream, s->p, length); xstream_copyin(g_input_stream, s->p, length);
/* in last packet, chan_flags & 0x02 will be true */ /* in last packet, chan_flags & 0x02 will be true */
if ((chan_flags & 2) == 0) if ((chan_flags & 2) == 0)
@ -148,8 +148,8 @@ dev_redir_data_in(struct stream *s, int chan_id, int chan_flags, int length,
} }
/* read header from incoming data */ /* read header from incoming data */
stream_rd_u16_le(ls, comp_type); xstream_rd_u16_le(ls, comp_type);
stream_rd_u16_le(ls, pktID); xstream_rd_u16_le(ls, pktID);
/* for now we only handle core type, not printers */ /* for now we only handle core type, not printers */
if (comp_type != RDPDR_CTYP_CORE) if (comp_type != RDPDR_CTYP_CORE)
@ -165,9 +165,9 @@ dev_redir_data_in(struct stream *s, int chan_id, int chan_flags, int length,
switch (pktID) switch (pktID)
{ {
case PAKID_CORE_CLIENTID_CONFIRM: case PAKID_CORE_CLIENTID_CONFIRM:
stream_seek(ls, 2); /* major version, we ignore it */ xstream_seek(ls, 2); /* major version, we ignore it */
stream_rd_u16_le(ls, minor_ver); xstream_rd_u16_le(ls, minor_ver);
stream_rd_u32_le(ls, g_clientID); xstream_rd_u32_le(ls, g_clientID);
g_client_rdp_version = minor_ver; g_client_rdp_version = minor_ver;
@ -223,7 +223,7 @@ done:
if (g_input_stream) if (g_input_stream)
{ {
stream_free(g_input_stream); xstream_free(g_input_stream);
g_input_stream = NULL; g_input_stream = NULL;
} }
@ -253,59 +253,59 @@ void dev_redir_send_server_core_cap_req()
struct stream *s; struct stream *s;
int bytes; int bytes;
stream_new(s, 1024); xstream_new(s, 1024);
/* setup header */ /* setup header */
stream_wr_u16_le(s, RDPDR_CTYP_CORE); xstream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_SERVER_CAPABILITY); xstream_wr_u16_le(s, PAKID_CORE_SERVER_CAPABILITY);
stream_wr_u16_le(s, 5); /* num of caps we are sending */ xstream_wr_u16_le(s, 5); /* num of caps we are sending */
stream_wr_u16_le(s, 0x0000); /* padding */ xstream_wr_u16_le(s, 0x0000); /* padding */
/* setup general capability */ /* setup general capability */
stream_wr_u16_le(s, CAP_GENERAL_TYPE); /* CapabilityType */ xstream_wr_u16_le(s, CAP_GENERAL_TYPE); /* CapabilityType */
stream_wr_u16_le(s, 44); /* CapabilityLength - len of this */ xstream_wr_u16_le(s, 44); /* CapabilityLength - len of this */
/* CAPABILITY_SET in bytes, inc */ /* CAPABILITY_SET in bytes, inc */
/* the header */ /* the header */
stream_wr_u32_le(s, 2); /* Version */ xstream_wr_u32_le(s, 2); /* Version */
stream_wr_u32_le(s, 2); /* O.S type */ xstream_wr_u32_le(s, 2); /* O.S type */
stream_wr_u32_le(s, 0); /* O.S version */ xstream_wr_u32_le(s, 0); /* O.S version */
stream_wr_u16_le(s, 1); /* protocol major version */ xstream_wr_u16_le(s, 1); /* protocol major version */
stream_wr_u16_le(s, g_client_rdp_version); /* protocol minor version */ xstream_wr_u16_le(s, g_client_rdp_version); /* protocol minor version */
stream_wr_u32_le(s, 0xffff); /* I/O code 1 */ xstream_wr_u32_le(s, 0xffff); /* I/O code 1 */
stream_wr_u32_le(s, 0); /* I/O code 2 */ xstream_wr_u32_le(s, 0); /* I/O code 2 */
stream_wr_u32_le(s, 7); /* Extended PDU */ xstream_wr_u32_le(s, 7); /* Extended PDU */
stream_wr_u32_le(s, 0); /* extra flags 1 */ xstream_wr_u32_le(s, 0); /* extra flags 1 */
stream_wr_u32_le(s, 0); /* extra flags 2 */ xstream_wr_u32_le(s, 0); /* extra flags 2 */
stream_wr_u32_le(s, 2); /* special type device cap */ xstream_wr_u32_le(s, 2); /* special type device cap */
/* setup printer capability */ /* setup printer capability */
stream_wr_u16_le(s, CAP_PRINTER_TYPE); xstream_wr_u16_le(s, CAP_PRINTER_TYPE);
stream_wr_u16_le(s, 8); xstream_wr_u16_le(s, 8);
stream_wr_u32_le(s, 1); xstream_wr_u32_le(s, 1);
/* setup serial port capability */ /* setup serial port capability */
stream_wr_u16_le(s, CAP_PORT_TYPE); xstream_wr_u16_le(s, CAP_PORT_TYPE);
stream_wr_u16_le(s, 8); xstream_wr_u16_le(s, 8);
stream_wr_u32_le(s, 1); xstream_wr_u32_le(s, 1);
/* setup file system capability */ /* setup file system capability */
stream_wr_u16_le(s, CAP_DRIVE_TYPE); /* CapabilityType */ xstream_wr_u16_le(s, CAP_DRIVE_TYPE); /* CapabilityType */
stream_wr_u16_le(s, 8); /* CapabilityLength - len of this */ xstream_wr_u16_le(s, 8); /* CapabilityLength - len of this */
/* CAPABILITY_SET in bytes, inc */ /* CAPABILITY_SET in bytes, inc */
/* the header */ /* the header */
stream_wr_u32_le(s, 2); /* Version */ xstream_wr_u32_le(s, 2); /* Version */
/* setup smart card capability */ /* setup smart card capability */
stream_wr_u16_le(s, CAP_SMARTCARD_TYPE); xstream_wr_u16_le(s, CAP_SMARTCARD_TYPE);
stream_wr_u16_le(s, 8); xstream_wr_u16_le(s, 8);
stream_wr_u32_le(s, 1); xstream_wr_u32_le(s, 1);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
} }
void dev_redir_send_server_clientID_confirm() void dev_redir_send_server_clientID_confirm()
@ -313,20 +313,20 @@ void dev_redir_send_server_clientID_confirm()
struct stream *s; struct stream *s;
int bytes; int bytes;
stream_new(s, 1024); xstream_new(s, 1024);
/* setup stream */ /* setup stream */
stream_wr_u16_le(s, RDPDR_CTYP_CORE); xstream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_CLIENTID_CONFIRM); xstream_wr_u16_le(s, PAKID_CORE_CLIENTID_CONFIRM);
stream_wr_u16_le(s, 0x0001); xstream_wr_u16_le(s, 0x0001);
stream_wr_u16_le(s, g_client_rdp_version); xstream_wr_u16_le(s, g_client_rdp_version);
stream_wr_u32_le(s, g_clientID); xstream_wr_u32_le(s, g_clientID);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
} }
void dev_redir_send_server_user_logged_on() void dev_redir_send_server_user_logged_on()
@ -334,17 +334,17 @@ void dev_redir_send_server_user_logged_on()
struct stream *s; struct stream *s;
int bytes; int bytes;
stream_new(s, 1024); xstream_new(s, 1024);
/* setup stream */ /* setup stream */
stream_wr_u16_le(s, RDPDR_CTYP_CORE); xstream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_USER_LOGGEDON); xstream_wr_u16_le(s, PAKID_CORE_USER_LOGGEDON);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
} }
void dev_redir_send_server_device_announce_resp(tui32 device_id) void dev_redir_send_server_device_announce_resp(tui32 device_id)
@ -352,19 +352,19 @@ void dev_redir_send_server_device_announce_resp(tui32 device_id)
struct stream *s; struct stream *s;
int bytes; int bytes;
stream_new(s, 1024); xstream_new(s, 1024);
/* setup stream */ /* setup stream */
stream_wr_u16_le(s, RDPDR_CTYP_CORE); xstream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_DEVICE_REPLY); xstream_wr_u16_le(s, PAKID_CORE_DEVICE_REPLY);
stream_wr_u32_le(s, device_id); xstream_wr_u32_le(s, device_id);
stream_wr_u32_le(s, 0); /* ResultCode */ xstream_wr_u32_le(s, 0); /* ResultCode */
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
} }
/** /**
@ -387,7 +387,7 @@ int dev_redir_send_drive_create_request(tui32 device_id, char *path,
/* to store path as unicode */ /* to store path as unicode */
len = strlen(path) * 2 + 2; len = strlen(path) * 2 + 2;
stream_new(s, 1024 + len); xstream_new(s, 1024 + len);
dev_redir_insert_dev_io_req_header(s, dev_redir_insert_dev_io_req_header(s,
device_id, device_id,
@ -396,22 +396,22 @@ int dev_redir_send_drive_create_request(tui32 device_id, char *path,
IRP_MJ_CREATE, IRP_MJ_CREATE,
0); 0);
stream_wr_u32_le(s, DesiredAccess); /* DesiredAccess */ xstream_wr_u32_le(s, DesiredAccess); /* DesiredAccess */
stream_wr_u32_le(s, 0); /* AllocationSize high unused */ xstream_wr_u32_le(s, 0); /* AllocationSize high unused */
stream_wr_u32_le(s, 0); /* AllocationSize low unused */ xstream_wr_u32_le(s, 0); /* AllocationSize low unused */
stream_wr_u32_le(s, 0); /* FileAttributes */ xstream_wr_u32_le(s, 0); /* FileAttributes */
stream_wr_u32_le(s, 0); /* SharedAccess */ xstream_wr_u32_le(s, 0); /* SharedAccess */
stream_wr_u32_le(s, CreateDisposition); /* CreateDisposition */ xstream_wr_u32_le(s, CreateDisposition); /* CreateDisposition */
stream_wr_u32_le(s, CreateOptions); /* CreateOptions */ xstream_wr_u32_le(s, CreateOptions); /* CreateOptions */
stream_wr_u32_le(s, len); /* PathLength */ xstream_wr_u32_le(s, len); /* PathLength */
devredir_cvt_to_unicode(s->p, path); /* path in unicode */ devredir_cvt_to_unicode(s->p, path); /* path in unicode */
stream_seek(s, len); xstream_seek(s, len);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return 0; return 0;
} }
@ -430,19 +430,19 @@ int dev_redir_send_drive_close_request(tui16 Component, tui16 PacketId,
struct stream *s; struct stream *s;
int bytes; int bytes;
stream_new(s, 1024); xstream_new(s, 1024);
dev_redir_insert_dev_io_req_header(s, DeviceId, FileId, CompletionId, dev_redir_insert_dev_io_req_header(s, DeviceId, FileId, CompletionId,
MajorFunction, MinorFunc); MajorFunction, MinorFunc);
if (pad_len) if (pad_len)
stream_seek(s, pad_len); xstream_seek(s, pad_len);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return 0; return 0;
} }
@ -472,7 +472,7 @@ void dev_redir_send_drive_dir_request(IRP *irp, tui32 device_id,
devredir_cvt_to_unicode(upath, Path); devredir_cvt_to_unicode(upath, Path);
} }
stream_new(s, 1024 + path_len); xstream_new(s, 1024 + path_len);
irp->completion_type = CID_DIRECTORY_CONTROL; irp->completion_type = CID_DIRECTORY_CONTROL;
dev_redir_insert_dev_io_req_header(s, dev_redir_insert_dev_io_req_header(s,
@ -483,29 +483,29 @@ void dev_redir_send_drive_dir_request(IRP *irp, tui32 device_id,
IRP_MN_QUERY_DIRECTORY); IRP_MN_QUERY_DIRECTORY);
#ifdef USE_SHORT_NAMES_IN_DIR_LISTING #ifdef USE_SHORT_NAMES_IN_DIR_LISTING
stream_wr_u32_le(s, FileBothDirectoryInformation); /* FsInformationClass */ xstream_wr_u32_le(s, FileBothDirectoryInformation); /* FsInformationClass */
#else #else
stream_wr_u32_le(s, FileDirectoryInformation); /* FsInformationClass */ xstream_wr_u32_le(s, FileDirectoryInformation); /* FsInformationClass */
#endif #endif
stream_wr_u8(s, InitialQuery); /* InitialQuery */ xstream_wr_u8(s, InitialQuery); /* InitialQuery */
if (!InitialQuery) if (!InitialQuery)
{ {
stream_wr_u32_le(s, 0); /* PathLength */ xstream_wr_u32_le(s, 0); /* PathLength */
stream_seek(s, 23); xstream_seek(s, 23);
} }
else else
{ {
stream_wr_u32_le(s, path_len); /* PathLength */ xstream_wr_u32_le(s, path_len); /* PathLength */
stream_seek(s, 23); /* Padding */ xstream_seek(s, 23); /* Padding */
stream_wr_string(s, upath, path_len); xstream_wr_string(s, upath, path_len);
} }
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
} }
/****************************************************************************** /******************************************************************************
@ -525,14 +525,14 @@ void dev_redir_proc_client_core_cap_resp(struct stream *s)
tui16 cap_len; tui16 cap_len;
tui32 cap_version; tui32 cap_version;
stream_rd_u16_le(s, num_caps); xstream_rd_u16_le(s, num_caps);
stream_seek(s, 2); /* padding */ xstream_seek(s, 2); /* padding */
for (i = 0; i < num_caps; i++) for (i = 0; i < num_caps; i++)
{ {
stream_rd_u16_le(s, cap_type); xstream_rd_u16_le(s, cap_type);
stream_rd_u16_le(s, cap_len); xstream_rd_u16_le(s, cap_len);
stream_rd_u32_le(s, cap_version); xstream_rd_u32_le(s, cap_version);
/* remove header length and version */ /* remove header length and version */
cap_len -= 8; cap_len -= 8;
@ -541,19 +541,19 @@ void dev_redir_proc_client_core_cap_resp(struct stream *s)
{ {
case CAP_GENERAL_TYPE: case CAP_GENERAL_TYPE:
log_debug("got CAP_GENERAL_TYPE"); log_debug("got CAP_GENERAL_TYPE");
stream_seek(s, cap_len); xstream_seek(s, cap_len);
break; break;
case CAP_PRINTER_TYPE: case CAP_PRINTER_TYPE:
log_debug("got CAP_PRINTER_TYPE"); log_debug("got CAP_PRINTER_TYPE");
g_is_printer_redir_supported = 1; g_is_printer_redir_supported = 1;
stream_seek(s, cap_len); xstream_seek(s, cap_len);
break; break;
case CAP_PORT_TYPE: case CAP_PORT_TYPE:
log_debug("got CAP_PORT_TYPE"); log_debug("got CAP_PORT_TYPE");
g_is_port_redir_supported = 1; g_is_port_redir_supported = 1;
stream_seek(s, cap_len); xstream_seek(s, cap_len);
break; break;
case CAP_DRIVE_TYPE: case CAP_DRIVE_TYPE:
@ -561,13 +561,13 @@ void dev_redir_proc_client_core_cap_resp(struct stream *s)
g_is_drive_redir_supported = 1; g_is_drive_redir_supported = 1;
if (cap_version == 2) if (cap_version == 2)
g_drive_redir_version = 2; g_drive_redir_version = 2;
stream_seek(s, cap_len); xstream_seek(s, cap_len);
break; break;
case CAP_SMARTCARD_TYPE: case CAP_SMARTCARD_TYPE:
log_debug("got CAP_SMARTCARD_TYPE"); log_debug("got CAP_SMARTCARD_TYPE");
g_is_smartcard_redir_supported = 1; g_is_smartcard_redir_supported = 1;
stream_seek(s, cap_len); xstream_seek(s, cap_len);
break; break;
} }
} }
@ -582,14 +582,14 @@ void dev_redir_proc_client_devlist_announce_req(struct stream *s)
tui32 device_data_len; tui32 device_data_len;
/* get number of devices being announced */ /* get number of devices being announced */
stream_rd_u32_le(s, device_count); xstream_rd_u32_le(s, device_count);
log_debug("num of devices announced: %d", device_count); log_debug("num of devices announced: %d", device_count);
for (i = 0; i < device_count; i++) for (i = 0; i < device_count; i++)
{ {
stream_rd_u32_le(s, device_type); xstream_rd_u32_le(s, device_type);
stream_rd_u32_le(s, g_device_id); /* LK_TODO need to support */ xstream_rd_u32_le(s, g_device_id); /* LK_TODO need to support */
/* multiple drives */ /* multiple drives */
switch (device_type) switch (device_type)
@ -608,11 +608,11 @@ void dev_redir_proc_client_devlist_announce_req(struct stream *s)
/* see section 2.2.1.3 of the protocol documentation */ /* see section 2.2.1.3 of the protocol documentation */
/* get device data len */ /* get device data len */
stream_rd_u32_le(s, device_data_len); xstream_rd_u32_le(s, device_data_len);
if (device_data_len) if (device_data_len)
{ {
stream_rd_string(g_full_name_for_filesystem, s, xstream_rd_string(g_full_name_for_filesystem, s,
device_data_len); device_data_len);
} }
log_debug("device_type=FILE_SYSTEM device_id=0x%x dosname=%s " log_debug("device_type=FILE_SYSTEM device_id=0x%x dosname=%s "
@ -649,9 +649,9 @@ void dev_redir_proc_device_iocompletion(struct stream *s)
tui32 IoStatus; tui32 IoStatus;
tui32 Length; tui32 Length;
stream_rd_u32_le(s, DeviceId); xstream_rd_u32_le(s, DeviceId);
stream_rd_u32_le(s, CompletionId); xstream_rd_u32_le(s, CompletionId);
stream_rd_u32_le(s, IoStatus); xstream_rd_u32_le(s, IoStatus);
/* LK_TODO need to check for IoStatus */ /* LK_TODO need to check for IoStatus */
@ -682,7 +682,7 @@ void dev_redir_proc_device_iocompletion(struct stream *s)
return; return;
} }
stream_rd_u32_le(s, irp->FileId); xstream_rd_u32_le(s, irp->FileId);
log_debug("got CID_CREATE_DIR_REQ IoStatus=0x%x FileId=%d", log_debug("got CID_CREATE_DIR_REQ IoStatus=0x%x FileId=%d",
IoStatus, irp->FileId); IoStatus, irp->FileId);
@ -690,7 +690,7 @@ void dev_redir_proc_device_iocompletion(struct stream *s)
break; break;
case CID_CREATE_OPEN_REQ: case CID_CREATE_OPEN_REQ:
stream_rd_u32_le(s, irp->FileId); xstream_rd_u32_le(s, irp->FileId);
log_debug("got CID_CREATE_OPEN_REQ IoStatus=0x%x FileId=%d", log_debug("got CID_CREATE_OPEN_REQ IoStatus=0x%x FileId=%d",
IoStatus, irp->FileId); IoStatus, irp->FileId);
fuse_data = dev_redir_fuse_data_dequeue(irp); fuse_data = dev_redir_fuse_data_dequeue(irp);
@ -702,14 +702,14 @@ void dev_redir_proc_device_iocompletion(struct stream *s)
case CID_READ: case CID_READ:
log_debug("got CID_READ"); log_debug("got CID_READ");
stream_rd_u32_le(s, Length); xstream_rd_u32_le(s, Length);
fuse_data = dev_redir_fuse_data_dequeue(irp); fuse_data = dev_redir_fuse_data_dequeue(irp);
xfuse_devredir_cb_read_file(fuse_data->data_ptr, s->p, Length); xfuse_devredir_cb_read_file(fuse_data->data_ptr, s->p, Length);
break; break;
case CID_WRITE: case CID_WRITE:
log_debug("got CID_WRITE"); log_debug("got CID_WRITE");
stream_rd_u32_le(s, Length); xstream_rd_u32_le(s, Length);
fuse_data = dev_redir_fuse_data_dequeue(irp); fuse_data = dev_redir_fuse_data_dequeue(irp);
xfuse_devredir_cb_write_file(fuse_data->data_ptr, s->p, Length); xfuse_devredir_cb_write_file(fuse_data->data_ptr, s->p, Length);
break; break;
@ -737,7 +737,7 @@ void dev_redir_proc_device_iocompletion(struct stream *s)
case CID_RMDIR_OR_FILE: case CID_RMDIR_OR_FILE:
log_debug("got CID_RMDIR_OR_FILE"); log_debug("got CID_RMDIR_OR_FILE");
stream_rd_u32_le(s, irp->FileId); xstream_rd_u32_le(s, irp->FileId);
devredir_proc_cid_rmdir_or_file(irp, IoStatus); devredir_proc_cid_rmdir_or_file(irp, IoStatus);
return; return;
break; break;
@ -749,7 +749,7 @@ void dev_redir_proc_device_iocompletion(struct stream *s)
case CID_RENAME_FILE: case CID_RENAME_FILE:
log_debug("got CID_RENAME_FILE"); log_debug("got CID_RENAME_FILE");
stream_rd_u32_le(s, irp->FileId); xstream_rd_u32_le(s, irp->FileId);
devredir_proc_cid_rename_file(irp, IoStatus); devredir_proc_cid_rename_file(irp, IoStatus);
return; return;
break; break;
@ -801,7 +801,7 @@ void dev_redir_proc_query_dir_response(IRP *irp,
char filename[256]; char filename[256];
int i = 0; int i = 0;
stream_rd_u32_le(s_in, Length); xstream_rd_u32_le(s_in, Length);
if ((IoStatus == NT_STATUS_UNSUCCESSFUL) || if ((IoStatus == NT_STATUS_UNSUCCESSFUL) ||
(IoStatus == STATUS_NO_MORE_FILES)) (IoStatus == STATUS_NO_MORE_FILES))
@ -827,22 +827,22 @@ void dev_redir_proc_query_dir_response(IRP *irp,
{ {
log_debug("processing FILE_DIRECTORY_INFORMATION structs"); log_debug("processing FILE_DIRECTORY_INFORMATION structs");
stream_rd_u32_le(s_in, NextEntryOffset); xstream_rd_u32_le(s_in, NextEntryOffset);
stream_seek(s_in, 4); /* FileIndex */ xstream_seek(s_in, 4); /* FileIndex */
stream_rd_u64_le(s_in, CreationTime); xstream_rd_u64_le(s_in, CreationTime);
stream_rd_u64_le(s_in, LastAccessTime); xstream_rd_u64_le(s_in, LastAccessTime);
stream_rd_u64_le(s_in, LastWriteTime); xstream_rd_u64_le(s_in, LastWriteTime);
stream_rd_u64_le(s_in, ChangeTime); xstream_rd_u64_le(s_in, ChangeTime);
stream_rd_u64_le(s_in, EndOfFile); xstream_rd_u64_le(s_in, EndOfFile);
stream_seek(s_in, 8); /* AllocationSize */ xstream_seek(s_in, 8); /* AllocationSize */
stream_rd_u32_le(s_in, FileAttributes); xstream_rd_u32_le(s_in, FileAttributes);
stream_rd_u32_le(s_in, FileNameLength); xstream_rd_u32_le(s_in, FileNameLength);
#ifdef USE_SHORT_NAMES_IN_DIR_LISTING #ifdef USE_SHORT_NAMES_IN_DIR_LISTING
stream_rd_u32_le(s_in, EaSize); xstream_rd_u32_le(s_in, EaSize);
stream_rd_u8(s_in, ShortNameLength); xstream_rd_u8(s_in, ShortNameLength);
stream_rd_u8(s_in, Reserved); xstream_rd_u8(s_in, Reserved);
stream_seek(s_in, 23); /* ShortName in Unicode */ xstream_seek(s_in, 23); /* ShortName in Unicode */
#endif #endif
devredir_cvt_from_unicode_len(filename, s_in->p, FileNameLength); devredir_cvt_from_unicode_len(filename, s_in->p, FileNameLength);
@ -1091,7 +1091,7 @@ int dev_redir_file_read(void *fusep, tui32 DeviceId, tui32 FileId,
IRP *irp; IRP *irp;
int bytes; int bytes;
stream_new(s, 1024); xstream_new(s, 1024);
if ((irp = dev_redir_irp_find_by_fileid(FileId)) == NULL) if ((irp = dev_redir_irp_find_by_fileid(FileId)) == NULL)
{ {
@ -1109,14 +1109,14 @@ int dev_redir_file_read(void *fusep, tui32 DeviceId, tui32 FileId,
IRP_MJ_READ, IRP_MJ_READ,
0); 0);
stream_wr_u32_le(s, Length); xstream_wr_u32_le(s, Length);
stream_wr_u64_le(s, Offset); xstream_wr_u64_le(s, Offset);
stream_seek(s, 20); xstream_seek(s, 20);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return 0; return 0;
} }
@ -1128,7 +1128,7 @@ int dev_redir_file_write(void *fusep, tui32 DeviceId, tui32 FileId,
IRP *irp; IRP *irp;
int bytes; int bytes;
stream_new(s, 1024 + Length); xstream_new(s, 1024 + Length);
if ((irp = dev_redir_irp_find_by_fileid(FileId)) == NULL) if ((irp = dev_redir_irp_find_by_fileid(FileId)) == NULL)
{ {
@ -1146,17 +1146,17 @@ int dev_redir_file_write(void *fusep, tui32 DeviceId, tui32 FileId,
IRP_MJ_WRITE, IRP_MJ_WRITE,
0); 0);
stream_wr_u32_le(s, Length); xstream_wr_u32_le(s, Length);
stream_wr_u64_le(s, Offset); xstream_wr_u64_le(s, Offset);
stream_seek(s, 20); /* padding */ xstream_seek(s, 20); /* padding */
/* now insert real data */ /* now insert real data */
stream_copyin(s, buf, Length); xstream_copyin(s, buf, Length);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return 0; return 0;
} }
@ -1423,13 +1423,13 @@ void dev_redir_insert_dev_io_req_header(struct stream *s,
tui32 MinorFunction) tui32 MinorFunction)
{ {
/* setup DR_DEVICE_IOREQUEST header */ /* setup DR_DEVICE_IOREQUEST header */
stream_wr_u16_le(s, RDPDR_CTYP_CORE); xstream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_DEVICE_IOREQUEST); xstream_wr_u16_le(s, PAKID_CORE_DEVICE_IOREQUEST);
stream_wr_u32_le(s, DeviceId); xstream_wr_u32_le(s, DeviceId);
stream_wr_u32_le(s, FileId); xstream_wr_u32_le(s, FileId);
stream_wr_u32_le(s, CompletionId); xstream_wr_u32_le(s, CompletionId);
stream_wr_u32_le(s, MajorFunction); xstream_wr_u32_le(s, MajorFunction);
stream_wr_u32_le(s, MinorFunction); xstream_wr_u32_le(s, MinorFunction);
} }
/** /**
@ -1486,8 +1486,8 @@ int dev_redir_string_ends_with(char *string, char c)
void dev_redir_insert_rdpdr_header(struct stream *s, tui16 Component, void dev_redir_insert_rdpdr_header(struct stream *s, tui16 Component,
tui16 PacketId) tui16 PacketId)
{ {
stream_wr_u16_le(s, Component); xstream_wr_u16_le(s, Component);
stream_wr_u16_le(s, PacketId); xstream_wr_u16_le(s, PacketId);
} }
void devredir_proc_cid_rmdir_or_file(IRP *irp, tui32 IoStatus) void devredir_proc_cid_rmdir_or_file(IRP *irp, tui32 IoStatus)
@ -1507,21 +1507,21 @@ void devredir_proc_cid_rmdir_or_file(IRP *irp, tui32 IoStatus)
return; return;
} }
stream_new(s, 1024); xstream_new(s, 1024);
irp->completion_type = CID_RMDIR_OR_FILE_RESP; irp->completion_type = CID_RMDIR_OR_FILE_RESP;
dev_redir_insert_dev_io_req_header(s, irp->device_id, irp->FileId, dev_redir_insert_dev_io_req_header(s, irp->device_id, irp->FileId,
irp->completion_id, irp->completion_id,
IRP_MJ_SET_INFORMATION, 0); IRP_MJ_SET_INFORMATION, 0);
stream_wr_u32_le(s, FileDispositionInformation); xstream_wr_u32_le(s, FileDispositionInformation);
stream_wr_u32_le(s, 0); /* length is zero */ xstream_wr_u32_le(s, 0); /* length is zero */
stream_seek(s, 24); /* padding */ xstream_seek(s, 24); /* padding */
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return; return;
} }
@ -1572,7 +1572,7 @@ void devredir_proc_cid_rename_file(IRP *irp, tui32 IoStatus)
return; return;
} }
stream_new(s, 1024); xstream_new(s, 1024);
irp->completion_type = CID_RENAME_FILE_RESP; irp->completion_type = CID_RENAME_FILE_RESP;
dev_redir_insert_dev_io_req_header(s, irp->device_id, irp->FileId, dev_redir_insert_dev_io_req_header(s, irp->device_id, irp->FileId,
@ -1582,21 +1582,21 @@ void devredir_proc_cid_rename_file(IRP *irp, tui32 IoStatus)
flen = strlen(irp->gen_buf) * 2 + 2; flen = strlen(irp->gen_buf) * 2 + 2;
sblen = 6 + flen; sblen = 6 + flen;
stream_wr_u32_le(s, FileRenameInformation); xstream_wr_u32_le(s, FileRenameInformation);
stream_wr_u32_le(s, sblen); /* Length */ xstream_wr_u32_le(s, sblen); /* Length */
stream_seek(s, 24); /* padding */ xstream_seek(s, 24); /* padding */
stream_wr_u8(s, 1); /* ReplaceIfExists */ xstream_wr_u8(s, 1); /* ReplaceIfExists */
stream_wr_u8(s, 0); /* RootDirectory */ xstream_wr_u8(s, 0); /* RootDirectory */
stream_wr_u32_le(s, flen); /* FileNameLength */ xstream_wr_u32_le(s, flen); /* FileNameLength */
/* filename in unicode */ /* filename in unicode */
devredir_cvt_to_unicode(s->p, irp->gen_buf); devredir_cvt_to_unicode(s->p, irp->gen_buf);
stream_seek(s, flen); xstream_seek(s, flen);
/* send to client */ /* send to client */
bytes = stream_len(s); bytes = xstream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes); send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s); xstream_free(s);
return; return;
} }

Write Preview
Loading…
Cancel
Save