jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

pass struct stream around, don't use just one

Browse Source
This commit is contained in:
jsorg71 2004-09-17 04:05:17 +00:00
parent 2ed9412912
commit 77943e08f9
11 changed files with 735 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
xrdp/parse.h
View File

@ -35,6 +35,7 @@ struct stream
char* sec_hdr; char* sec_hdr;
char* rdp_hdr; char* rdp_hdr;
char* channel_hdr; char* channel_hdr;
char* next_packet;
}; };
#define s_check(s) (s->p <= s->end) #define s_check(s) (s->p <= s->end)
@ -43,6 +44,11 @@ struct stream
#define s_check_end(s) (s->p == s->end) #define s_check_end(s) (s->p == s->end)
#define make_stream(s) \
{ \
s = (struct stream*)g_malloc(sizeof(struct stream), 1); \
} \
#define init_stream(s, v) \ #define init_stream(s, v) \
{ \ { \
if (v > s->size) \ if (v > s->size) \
@ -53,8 +59,16 @@ struct stream
s->p = s->data; \ s->p = s->data; \
s->end = s->data; \ s->end = s->data; \
s->size = v; \ s->size = v; \
s->next_packet = 0; \
} }
#define free_stream(s) \
{ \
if (s != 0) \
g_free(s->data); \
g_free(s); \
} \
#define s_push_layer(s, h, n) \ #define s_push_layer(s, h, n) \
{ \ { \
s->h = s->p; \ s->h = s->p; \

39
xrdp/xrdp.h
View File

@ -89,48 +89,49 @@ int g_file_lock(int fd, int start, int len);
/* xrdp_tcp.c */ /* xrdp_tcp.c */
struct xrdp_tcp* xrdp_tcp_create(struct xrdp_iso* owner); struct xrdp_tcp* xrdp_tcp_create(struct xrdp_iso* owner);
void xrdp_tcp_delete(struct xrdp_tcp* self); void xrdp_tcp_delete(struct xrdp_tcp* self);
int xrdp_tcp_init(struct xrdp_tcp* self, int len); int xrdp_tcp_init(struct xrdp_tcp* self, struct stream* s);
int xrdp_tcp_recv(struct xrdp_tcp* self, int len); int xrdp_tcp_recv(struct xrdp_tcp* self, struct stream* s, int len);
int xrdp_tcp_send(struct xrdp_tcp* self); int xrdp_tcp_send(struct xrdp_tcp* self, struct stream* s);
/* xrdp_iso.c */ /* xrdp_iso.c */
struct xrdp_iso* xrdp_iso_create(struct xrdp_mcs* owner); struct xrdp_iso* xrdp_iso_create(struct xrdp_mcs* owner);
void xrdp_iso_delete(struct xrdp_iso* self); void xrdp_iso_delete(struct xrdp_iso* self);
int xrdp_iso_init(struct xrdp_iso* self, int len); int xrdp_iso_init(struct xrdp_iso* self, struct stream* s);
int xrdp_iso_recv(struct xrdp_iso* self); int xrdp_iso_recv(struct xrdp_iso* self, struct stream* s);
int xrdp_iso_send(struct xrdp_iso* self); int xrdp_iso_send(struct xrdp_iso* self, struct stream* s);
int xrdp_iso_incoming(struct xrdp_iso* self); int xrdp_iso_incoming(struct xrdp_iso* self);
/* xrdp_mcs.c */ /* xrdp_mcs.c */
struct xrdp_mcs* xrdp_mcs_create(struct xrdp_sec* owner); struct xrdp_mcs* xrdp_mcs_create(struct xrdp_sec* owner);
void xrdp_mcs_delete(struct xrdp_mcs* self); void xrdp_mcs_delete(struct xrdp_mcs* self);
int xrdp_mcs_init(struct xrdp_mcs* self, int len); int xrdp_mcs_init(struct xrdp_mcs* self, struct stream* s);
int xrdp_mcs_recv(struct xrdp_mcs* self, int* chan); int xrdp_mcs_recv(struct xrdp_mcs* self, struct stream* s, int* chan);
int xrdp_mcs_send(struct xrdp_mcs* self); int xrdp_mcs_send(struct xrdp_mcs* self, struct stream* s);
int xrdp_mcs_incoming(struct xrdp_mcs* self); int xrdp_mcs_incoming(struct xrdp_mcs* self);
int xrdp_mcs_disconnect(struct xrdp_mcs* self); int xrdp_mcs_disconnect(struct xrdp_mcs* self);
/* xrdp_sec.c */ /* xrdp_sec.c */
struct xrdp_sec* xrdp_sec_create(struct xrdp_rdp* owner); struct xrdp_sec* xrdp_sec_create(struct xrdp_rdp* owner);
void xrdp_sec_delete(struct xrdp_sec* self); void xrdp_sec_delete(struct xrdp_sec* self);
int xrdp_sec_init(struct xrdp_sec* self, int len); int xrdp_sec_init(struct xrdp_sec* self, struct stream* s);
int xrdp_sec_recv(struct xrdp_sec* self, int* chan); int xrdp_sec_recv(struct xrdp_sec* self, struct stream* s, int* chan);
int xrdp_sec_send(struct xrdp_sec* self, int flags); int xrdp_sec_send(struct xrdp_sec* self, struct stream* s, int flags);
int xrdp_rdp_send_data(struct xrdp_rdp* self, int data_pdu_type);
int xrdp_sec_incoming(struct xrdp_sec* self); int xrdp_sec_incoming(struct xrdp_sec* self);
int xrdp_sec_disconnect(struct xrdp_sec* self); int xrdp_sec_disconnect(struct xrdp_sec* self);
/* xrdp_rdp.c */ /* xrdp_rdp.c */
struct xrdp_rdp* xrdp_rdp_create(struct xrdp_process* owner); struct xrdp_rdp* xrdp_rdp_create(struct xrdp_process* owner);
void xrdp_rdp_delete(struct xrdp_rdp* self); void xrdp_rdp_delete(struct xrdp_rdp* self);
int xrdp_rdp_init(struct xrdp_rdp* self, int len); int xrdp_rdp_init(struct xrdp_rdp* self, struct stream* s);
int xrdp_rdp_init_data(struct xrdp_rdp* self, int len); int xrdp_rdp_init_data(struct xrdp_rdp* self, struct stream* s);
int xrdp_rdp_recv(struct xrdp_rdp* self, int* code); int xrdp_rdp_recv(struct xrdp_rdp* self, struct stream* s, int* code);
int xrdp_rdp_send(struct xrdp_rdp* self, int pdu_type); int xrdp_rdp_send(struct xrdp_rdp* self, struct stream* s, int pdu_type);
int xrdp_rdp_send_data(struct xrdp_rdp* self, struct stream* s,
int data_pdu_type);
int xrdp_rdp_incoming(struct xrdp_rdp* self); int xrdp_rdp_incoming(struct xrdp_rdp* self);
int xrdp_rdp_send_demand_active(struct xrdp_rdp* self); int xrdp_rdp_send_demand_active(struct xrdp_rdp* self);
int xrdp_rdp_process_confirm_active(struct xrdp_rdp* self); int xrdp_rdp_process_confirm_active(struct xrdp_rdp* self, struct stream* s);
int xrdp_rdp_process_data(struct xrdp_rdp* self); int xrdp_rdp_process_data(struct xrdp_rdp* self, struct stream* s);
int xrdp_rdp_disconnect(struct xrdp_rdp* self); int xrdp_rdp_disconnect(struct xrdp_rdp* self);
/* xrdp_orders.c */ /* xrdp_orders.c */

117
xrdp/xrdp_iso.c
View File

@ -28,8 +28,6 @@ struct xrdp_iso* xrdp_iso_create(struct xrdp_mcs* owner)
self = (struct xrdp_iso*)g_malloc(sizeof(struct xrdp_iso), 1); self = (struct xrdp_iso*)g_malloc(sizeof(struct xrdp_iso), 1);
self->mcs_layer = owner; self->mcs_layer = owner;
self->in_s = owner->in_s;
self->out_s = owner->out_s;
self->tcp_layer = xrdp_tcp_create(self); self->tcp_layer = xrdp_tcp_create(self);
return self; return self;
} }
@ -45,42 +43,38 @@ void xrdp_iso_delete(struct xrdp_iso* self)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_iso_recv_msg(struct xrdp_iso* self, int* code) int xrdp_iso_recv_msg(struct xrdp_iso* self, struct stream* s, int* code)
{ {
int ver; int ver;
int len; int len;
*code = 0; *code = 0;
if (xrdp_tcp_recv(self->tcp_layer, 4) != 0) if (xrdp_tcp_recv(self->tcp_layer, s, 4) != 0)
return 1; return 1;
in_uint8(self->in_s, ver); in_uint8(s, ver);
if (ver != 3) if (ver != 3)
return 1; return 1;
in_uint8s(self->in_s, 1); in_uint8s(s, 1);
in_uint16_be(self->in_s, len); in_uint16_be(s, len);
if (xrdp_tcp_recv(self->tcp_layer, len - 4) != 0) if (xrdp_tcp_recv(self->tcp_layer, s, len - 4) != 0)
return 1; return 1;
in_uint8s(self->in_s, 1); in_uint8s(s, 1);
in_uint8(self->in_s, *code); in_uint8(s, *code);
if (*code == ISO_PDU_DT) if (*code == ISO_PDU_DT)
{ in_uint8s(s, 1)
in_uint8s(self->in_s, 1);
}
else else
{ in_uint8s(s, 5);
in_uint8s(self->in_s, 5);
}
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_iso_recv(struct xrdp_iso* self) int xrdp_iso_recv(struct xrdp_iso* self, struct stream* s)
{ {
int code; int code;
DEBUG((" in xrdp_iso_recv\n\r")); DEBUG((" in xrdp_iso_recv\n\r"));
if (xrdp_iso_recv_msg(self, &code) != 0) if (xrdp_iso_recv_msg(self, s, &code) != 0)
return 1; return 1;
if (code != ISO_PDU_DT) if (code != ISO_PDU_DT)
return 1; return 1;
@ -89,20 +83,20 @@ int xrdp_iso_recv(struct xrdp_iso* self)
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_iso_send_msg(struct xrdp_iso* self, int code) int xrdp_iso_send_msg(struct xrdp_iso* self, struct stream* s, int code)
{ {
if (xrdp_tcp_init(self->tcp_layer, 11) != 0) if (xrdp_tcp_init(self->tcp_layer, s) != 0)
return 1; return 1;
out_uint8(self->out_s, 3); out_uint8(s, 3);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint16_be(self->out_s, 11); /* length */ out_uint16_be(s, 11); /* length */
out_uint8(self->out_s, 8); out_uint8(s, 8);
out_uint8(self->out_s, code); out_uint8(s, code);
out_uint16_le(self->out_s, 0); out_uint16_le(s, 0);
out_uint16_le(self->out_s, 0); out_uint16_le(s, 0);
out_uint8(self->out_s, 0); out_uint8(s, 0);
s_mark_end(self->out_s); s_mark_end(s);
if (xrdp_tcp_send(self->tcp_layer) != 0) if (xrdp_tcp_send(self->tcp_layer, s) != 0)
return 1; return 1;
return 0; return 0;
} }
@ -112,43 +106,56 @@ int xrdp_iso_send_msg(struct xrdp_iso* self, int code)
int xrdp_iso_incoming(struct xrdp_iso* self) int xrdp_iso_incoming(struct xrdp_iso* self)
{ {
int code; int code;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
DEBUG((" in xrdp_iso_incoming\n\r")); DEBUG((" in xrdp_iso_incoming\n\r"));
if (xrdp_iso_recv_msg(self, &code) != 0) if (xrdp_iso_recv_msg(self, s, &code) != 0)
return 1;
if (code != ISO_PDU_CR)
return 1;
if (xrdp_iso_send_msg(self, ISO_PDU_CC) != 0)
return 1;
DEBUG((" out xrdp_iso_incoming\n\r"));
return 0;
}
/*****************************************************************************/
/* returns error */
int xrdp_iso_init(struct xrdp_iso* self, int len)
{ {
xrdp_tcp_init(self->tcp_layer, len + 7); free_stream(s);
s_push_layer(self->out_s, iso_hdr, 7); return 1;
}
if (code != ISO_PDU_CR)
{
free_stream(s);
return 1;
}
if (xrdp_iso_send_msg(self, s, ISO_PDU_CC) != 0)
{
free_stream(s);
return 1;
}
DEBUG((" out xrdp_iso_incoming\n\r"));
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_iso_send(struct xrdp_iso* self) int xrdp_iso_init(struct xrdp_iso* self, struct stream* s)
{
xrdp_tcp_init(self->tcp_layer, s);
s_push_layer(s, iso_hdr, 7);
return 0;
}
/*****************************************************************************/
/* returns error */
int xrdp_iso_send(struct xrdp_iso* self, struct stream* s)
{ {
int len; int len;
DEBUG((" in xrdp_iso_send\n\r")); DEBUG((" in xrdp_iso_send\n\r"));
s_pop_layer(self->out_s, iso_hdr); s_pop_layer(s, iso_hdr);
len = self->out_s->end - self->out_s->p; len = s->end - s->p;
out_uint8(self->out_s, 3); out_uint8(s, 3);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint16_be(self->out_s, len); out_uint16_be(s, len);
out_uint8(self->out_s, 2); out_uint8(s, 2);
out_uint8(self->out_s, ISO_PDU_DT); out_uint8(s, ISO_PDU_DT);
out_uint8(self->out_s, 0x80); out_uint8(s, 0x80);
if (xrdp_tcp_send(self->tcp_layer) != 0) if (xrdp_tcp_send(self->tcp_layer, s) != 0)
return 1; return 1;
DEBUG((" out xrdp_iso_send\n\r")); DEBUG((" out xrdp_iso_send\n\r"));
return 0; return 0;

368
xrdp/xrdp_mcs.c
View File

@ -28,8 +28,6 @@ struct xrdp_mcs* xrdp_mcs_create(struct xrdp_sec* owner)
self = (struct xrdp_mcs*)g_malloc(sizeof(struct xrdp_mcs), 1); self = (struct xrdp_mcs*)g_malloc(sizeof(struct xrdp_mcs), 1);
self->sec_layer = owner; self->sec_layer = owner;
self->in_s = owner->in_s;
self->out_s = owner->out_s;
self->userid = 1; self->userid = 1;
self->chanid = 1001; self->chanid = 1001;
self->client_mcs_data = &owner->client_mcs_data; self->client_mcs_data = &owner->client_mcs_data;
@ -51,22 +49,33 @@ void xrdp_mcs_delete(struct xrdp_mcs* self)
/* returns error */ /* returns error */
int xrdp_mcs_send_cjcf(struct xrdp_mcs* self, int chanid) int xrdp_mcs_send_cjcf(struct xrdp_mcs* self, int chanid)
{ {
if (xrdp_iso_init(self->iso_layer, 8) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint8(self->out_s, (MCS_CJCF << 2) | 2); }
out_uint8(self->out_s, 0); out_uint8(s, (MCS_CJCF << 2) | 2);
out_uint16_be(self->out_s, self->userid); out_uint8(s, 0);
out_uint16_be(self->out_s, chanid); out_uint16_be(s, self->userid);
out_uint16_be(self->out_s, chanid); out_uint16_be(s, chanid);
s_mark_end(self->out_s); out_uint16_be(s, chanid);
if (xrdp_iso_send(self->iso_layer) != 0) s_mark_end(s);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_recv(struct xrdp_mcs* self, int* chan) int xrdp_mcs_recv(struct xrdp_mcs* self, struct stream* s, int* chan)
{ {
int appid; int appid;
int opcode; int opcode;
@ -75,9 +84,9 @@ int xrdp_mcs_recv(struct xrdp_mcs* self, int* chan)
DEBUG((" in xrdp_mcs_recv\n\r")); DEBUG((" in xrdp_mcs_recv\n\r"));
while (1) while (1)
{ {
if (xrdp_iso_recv(self->iso_layer) != 0) if (xrdp_iso_recv(self->iso_layer, s) != 0)
return 1; return 1;
in_uint8(self->in_s, opcode); in_uint8(s, opcode);
appid = opcode >> 2; appid = opcode >> 2;
if (appid == MCS_DPUM) if (appid == MCS_DPUM)
return 1; return 1;
@ -93,19 +102,20 @@ int xrdp_mcs_recv(struct xrdp_mcs* self, int* chan)
DEBUG((" out xrdp_mcs_recv err got 0x%x need MCS_SDRQ\n\r", appid)); DEBUG((" out xrdp_mcs_recv err got 0x%x need MCS_SDRQ\n\r", appid));
return 1; return 1;
} }
in_uint8s(self->in_s, 2); in_uint8s(s, 2);
in_uint16_be(self->in_s, *chan); in_uint16_be(s, *chan);
in_uint8s(self->in_s, 1); in_uint8s(s, 1);
in_uint8(self->in_s, len); in_uint8(s, len);
if (len & 0x80) if (len & 0x80)
in_uint8s(self->in_s, 1); in_uint8s(s, 1);
DEBUG((" out xrdp_mcs_recv\n\r")); DEBUG((" out xrdp_mcs_recv\n\r"));
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_ber_parse_header(struct xrdp_mcs* self, int tag_val, int* len) int xrdp_mcs_ber_parse_header(struct xrdp_mcs* self, struct stream* s,
int tag_val, int* len)
{ {
int tag; int tag;
int l; int l;
@ -113,29 +123,29 @@ int xrdp_mcs_ber_parse_header(struct xrdp_mcs* self, int tag_val, int* len)
if (tag_val > 0xff) if (tag_val > 0xff)
{ {
in_uint16_be(self->in_s, tag); in_uint16_be(s, tag);
} }
else else
{ {
in_uint8(self->in_s, tag); in_uint8(s, tag);
} }
if (tag != tag_val) if (tag != tag_val)
return 1; return 1;
in_uint8(self->in_s, l); in_uint8(s, l);
if (l & 0x80) if (l & 0x80)
{ {
l = l & ~0x80; l = l & ~0x80;
*len = 0; *len = 0;
while (l > 0) while (l > 0)
{ {
in_uint8(self->in_s, i); in_uint8(s, i);
*len = (*len << 8) | i; *len = (*len << 8) | i;
l--; l--;
} }
} }
else else
*len = l; *len = l;
if (s_check(self->in_s)) if (s_check(s))
return 0; return 0;
else else
return 1; return 1;
@ -143,14 +153,14 @@ int xrdp_mcs_ber_parse_header(struct xrdp_mcs* self, int tag_val, int* len)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_parse_domain_params(struct xrdp_mcs* self) int xrdp_mcs_parse_domain_params(struct xrdp_mcs* self, struct stream* s)
{ {
int len; int len;
if (xrdp_mcs_ber_parse_header(self, MCS_TAG_DOMAIN_PARAMS, &len) != 0) if (xrdp_mcs_ber_parse_header(self, s, MCS_TAG_DOMAIN_PARAMS, &len) != 0)
return 1; return 1;
in_uint8s(self->in_s, len); in_uint8s(s, len);
if (s_check(self->in_s)) if (s_check(s))
return 0; return 0;
else else
return 1; return 1;
@ -161,58 +171,107 @@ int xrdp_mcs_parse_domain_params(struct xrdp_mcs* self)
int xrdp_mcs_recv_connect_initial(struct xrdp_mcs* self) int xrdp_mcs_recv_connect_initial(struct xrdp_mcs* self)
{ {
int len; int len;
struct stream* s;
if (xrdp_iso_recv(self->iso_layer) != 0) make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
if (xrdp_mcs_ber_parse_header(self, MCS_CONNECT_INITIAL, &len) != 0) }
if (xrdp_mcs_ber_parse_header(self, s, MCS_CONNECT_INITIAL, &len) != 0)
{
free_stream(s);
return 1; return 1;
if (xrdp_mcs_ber_parse_header(self, BER_TAG_OCTET_STRING, &len) != 0) }
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_OCTET_STRING, &len) != 0)
{
free_stream(s);
return 1; return 1;
in_uint8s(self->in_s, len); }
if (xrdp_mcs_ber_parse_header(self, BER_TAG_OCTET_STRING, &len) != 0) in_uint8s(s, len);
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_OCTET_STRING, &len) != 0)
{
free_stream(s);
return 1; return 1;
in_uint8s(self->in_s, len); }
if (xrdp_mcs_ber_parse_header(self, BER_TAG_BOOLEAN, &len) != 0) in_uint8s(s, len);
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_BOOLEAN, &len) != 0)
{
free_stream(s);
return 1; return 1;
in_uint8s(self->in_s, len); }
if (xrdp_mcs_parse_domain_params(self) != 0) in_uint8s(s, len);
if (xrdp_mcs_parse_domain_params(self, s) != 0)
{
free_stream(s);
return 1; return 1;
if (xrdp_mcs_parse_domain_params(self) != 0) }
if (xrdp_mcs_parse_domain_params(self, s) != 0)
{
free_stream(s);
return 1; return 1;
if (xrdp_mcs_parse_domain_params(self) != 0) }
if (xrdp_mcs_parse_domain_params(self, s) != 0)
{
free_stream(s);
return 1; return 1;
if (xrdp_mcs_ber_parse_header(self, BER_TAG_OCTET_STRING, &len) != 0) }
if (xrdp_mcs_ber_parse_header(self, s, BER_TAG_OCTET_STRING, &len) != 0)
{
free_stream(s);
return 1; return 1;
}
/* make a copy of client mcs data */ /* make a copy of client mcs data */
init_stream(self->client_mcs_data, len); init_stream(self->client_mcs_data, len);
out_uint8a(self->client_mcs_data, self->in_s->p, len); out_uint8a(self->client_mcs_data, s->p, len);
in_uint8s(self->in_s, len); in_uint8s(s, len);
s_mark_end(self->client_mcs_data); s_mark_end(self->client_mcs_data);
if (s_check_end(self->in_s)) if (s_check_end(s))
{
free_stream(s);
return 0; return 0;
}
else else
{
free_stream(s);
return 1; return 1;
} }
}
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_recv_edrq(struct xrdp_mcs* self) int xrdp_mcs_recv_edrq(struct xrdp_mcs* self)
{ {
int opcode; int opcode;
struct stream* s;
if (xrdp_iso_recv(self->iso_layer) != 0) make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
in_uint8(self->in_s, opcode); }
in_uint8(s, opcode);
if ((opcode >> 2) != MCS_EDRQ) if ((opcode >> 2) != MCS_EDRQ)
{
free_stream(s);
return 1; return 1;
in_uint8s(self->in_s, 2); }
in_uint8s(self->in_s, 2); in_uint8s(s, 2);
in_uint8s(s, 2);
if (opcode & 2) if (opcode & 2)
{ {
in_uint16_be(self->in_s, self->userid); in_uint16_be(s, self->userid);
} }
if (!(s_check_end(self->in_s))) if (!(s_check_end(s)))
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
@ -221,18 +280,31 @@ int xrdp_mcs_recv_edrq(struct xrdp_mcs* self)
int xrdp_mcs_recv_aurq(struct xrdp_mcs* self) int xrdp_mcs_recv_aurq(struct xrdp_mcs* self)
{ {
int opcode; int opcode;
struct stream* s;
if (xrdp_iso_recv(self->iso_layer) != 0) make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
in_uint8(self->in_s, opcode); }
in_uint8(s, opcode);
if ((opcode >> 2) != MCS_AURQ) if ((opcode >> 2) != MCS_AURQ)
{
free_stream(s);
return 1; return 1;
}
if (opcode & 2) if (opcode & 2)
{ {
in_uint16_be(self->in_s, self->userid); in_uint16_be(s, self->userid);
} }
if (!(s_check_end(self->in_s))) if (!(s_check_end(s)))
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
@ -240,14 +312,25 @@ int xrdp_mcs_recv_aurq(struct xrdp_mcs* self)
/* returns error */ /* returns error */
int xrdp_mcs_send_aucf(struct xrdp_mcs* self) int xrdp_mcs_send_aucf(struct xrdp_mcs* self)
{ {
if (xrdp_iso_init(self->iso_layer, 4) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint8(self->out_s, ((MCS_AUCF << 2) | 2)); }
out_uint8s(self->out_s, 1); out_uint8(s, ((MCS_AUCF << 2) | 2));
out_uint16_be(self->out_s, self->userid); out_uint8s(s, 1);
s_mark_end(self->out_s); out_uint16_be(s, self->userid);
if (xrdp_iso_send(self->iso_layer) != 0) s_mark_end(s);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
@ -256,91 +339,106 @@ int xrdp_mcs_send_aucf(struct xrdp_mcs* self)
int xrdp_mcs_recv_cjrq(struct xrdp_mcs* self) int xrdp_mcs_recv_cjrq(struct xrdp_mcs* self)
{ {
int opcode; int opcode;
struct stream* s;
if (xrdp_iso_recv(self->iso_layer) != 0) make_stream(s);
init_stream(s, 8192);
if (xrdp_iso_recv(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
in_uint8(self->in_s, opcode); }
in_uint8(s, opcode);
if ((opcode >> 2) != MCS_CJRQ) if ((opcode >> 2) != MCS_CJRQ)
{
free_stream(s);
return 1; return 1;
in_uint8s(self->in_s, 4); }
in_uint8s(s, 4);
if (opcode & 2) if (opcode & 2)
{ {
in_uint8s(self->in_s, 2); in_uint8s(s, 2);
} }
if (!(s_check_end(self->in_s))) if (!(s_check_end(s)))
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_ber_out_header(struct xrdp_mcs* self, int tag_val, int len) int xrdp_mcs_ber_out_header(struct xrdp_mcs* self, struct stream* s,
int tag_val, int len)
{ {
if (tag_val > 0xff) if (tag_val > 0xff)
{ {
out_uint16_be(self->out_s, tag_val); out_uint16_be(s, tag_val);
} }
else else
{ {
out_uint8(self->out_s, tag_val); out_uint8(s, tag_val);
} }
if (len >= 0x80) if (len >= 0x80)
{ {
out_uint8(self->out_s, 0x82); out_uint8(s, 0x82);
out_uint16_be(self->out_s, len); out_uint16_be(s, len);
} }
else else
{ {
out_uint8(self->out_s, len); out_uint8(s, len);
} }
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_ber_out_int8(struct xrdp_mcs* self, int value) int xrdp_mcs_ber_out_int8(struct xrdp_mcs* self, struct stream* s, int value)
{ {
xrdp_mcs_ber_out_header(self, BER_TAG_INTEGER, 1); xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1);
out_uint8(self->out_s, value); out_uint8(s, value);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_ber_out_int16(struct xrdp_mcs* self, int value) int xrdp_mcs_ber_out_int16(struct xrdp_mcs* self, struct stream* s, int value)
{ {
xrdp_mcs_ber_out_header(self, BER_TAG_INTEGER, 2); xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 2);
out_uint8(self->out_s, value >> 8); out_uint8(s, (value >> 8));
out_uint8(self->out_s, value); out_uint8(s, value);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_ber_out_int24(struct xrdp_mcs* self, int value) int xrdp_mcs_ber_out_int24(struct xrdp_mcs* self, struct stream* s, int value)
{ {
xrdp_mcs_ber_out_header(self, BER_TAG_INTEGER, 3); xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 3);
out_uint8(self->out_s, value >> 16); out_uint8(s, (value >> 16));
out_uint8(self->out_s, value >> 8); out_uint8(s, (value >> 8));
out_uint8(self->out_s, value); out_uint8(s, value);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_out_domain_params(struct xrdp_mcs* self, int max_channels, int xrdp_mcs_out_domain_params(struct xrdp_mcs* self, struct stream* s,
int max_channels,
int max_users, int max_tokens, int max_users, int max_tokens,
int max_pdu_size) int max_pdu_size)
{ {
xrdp_mcs_ber_out_header(self, MCS_TAG_DOMAIN_PARAMS, 26); xrdp_mcs_ber_out_header(self, s, MCS_TAG_DOMAIN_PARAMS, 26);
xrdp_mcs_ber_out_int8(self, max_channels); xrdp_mcs_ber_out_int8(self, s, max_channels);
xrdp_mcs_ber_out_int8(self, max_users); xrdp_mcs_ber_out_int8(self, s, max_users);
xrdp_mcs_ber_out_int8(self, max_tokens); xrdp_mcs_ber_out_int8(self, s, max_tokens);
xrdp_mcs_ber_out_int8(self, 1); xrdp_mcs_ber_out_int8(self, s, 1);
xrdp_mcs_ber_out_int8(self, 0); xrdp_mcs_ber_out_int8(self, s, 0);
xrdp_mcs_ber_out_int8(self, 1); xrdp_mcs_ber_out_int8(self, s, 1);
xrdp_mcs_ber_out_int24(self, max_pdu_size); xrdp_mcs_ber_out_int24(self, s, max_pdu_size);
xrdp_mcs_ber_out_int8(self, 2); xrdp_mcs_ber_out_int8(self, s, 2);
return 0; return 0;
} }
@ -349,21 +447,28 @@ int xrdp_mcs_out_domain_params(struct xrdp_mcs* self, int max_channels,
int xrdp_mcs_send_connect_response(struct xrdp_mcs* self) int xrdp_mcs_send_connect_response(struct xrdp_mcs* self)
{ {
int data_len; int data_len;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
data_len = self->server_mcs_data->end - self->server_mcs_data->data; data_len = self->server_mcs_data->end - self->server_mcs_data->data;
xrdp_iso_init(self->iso_layer, 512); xrdp_iso_init(self->iso_layer, s);
xrdp_mcs_ber_out_header(self, MCS_CONNECT_RESPONSE, 313); xrdp_mcs_ber_out_header(self, s, MCS_CONNECT_RESPONSE, 313);
xrdp_mcs_ber_out_header(self, BER_TAG_RESULT, 1); xrdp_mcs_ber_out_header(self, s, BER_TAG_RESULT, 1);
out_uint8(self->out_s, 0); out_uint8(s, 0);
xrdp_mcs_ber_out_header(self, BER_TAG_INTEGER, 1); xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1);
out_uint8(self->out_s, 0); out_uint8(s, 0);
xrdp_mcs_out_domain_params(self, 2, 2, 0, 0xffff); xrdp_mcs_out_domain_params(self, s, 2, 2, 0, 0xffff);
xrdp_mcs_ber_out_header(self, BER_TAG_OCTET_STRING, data_len); xrdp_mcs_ber_out_header(self, s, BER_TAG_OCTET_STRING, data_len);
/* mcs data */ /* mcs data */
out_uint8a(self->out_s, self->server_mcs_data->data, data_len); out_uint8a(s, self->server_mcs_data->data, data_len);
s_mark_end(self->out_s); s_mark_end(s);
if (xrdp_iso_send(self->iso_layer) != 0) if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
@ -398,29 +503,29 @@ int xrdp_mcs_incoming(struct xrdp_mcs* self)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_init(struct xrdp_mcs* self, int len) int xrdp_mcs_init(struct xrdp_mcs* self, struct stream* s)
{ {
xrdp_iso_init(self->iso_layer, len + 8); xrdp_iso_init(self->iso_layer, s);
s_push_layer(self->out_s, mcs_hdr, 8); s_push_layer(s, mcs_hdr, 8);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_mcs_send(struct xrdp_mcs* self) int xrdp_mcs_send(struct xrdp_mcs* self, struct stream* s)
{ {
int len; int len;
DEBUG((" in xrdp_mcs_send\n\r")); DEBUG((" in xrdp_mcs_send\n\r"));
s_pop_layer(self->out_s, mcs_hdr); s_pop_layer(s, mcs_hdr);
len = (self->out_s->end - self->out_s->p) - 8; len = (s->end - s->p) - 8;
len = len | 0x8000; len = len | 0x8000;
out_uint8(self->out_s, MCS_SDIN << 2); out_uint8(s, MCS_SDIN << 2);
out_uint16_be(self->out_s, self->userid); out_uint16_be(s, self->userid);
out_uint16_be(self->out_s, MCS_GLOBAL_CHANNEL); out_uint16_be(s, MCS_GLOBAL_CHANNEL);
out_uint8(self->out_s, 0x70); out_uint8(s, 0x70);
out_uint16_be(self->out_s, len); out_uint16_be(s, len);
if (xrdp_iso_send(self->iso_layer) != 0) if (xrdp_iso_send(self->iso_layer, s) != 0)
return 1; return 1;
DEBUG((" out xrdp_mcs_send\n\r")); DEBUG((" out xrdp_mcs_send\n\r"));
return 0; return 0;
@ -431,18 +536,29 @@ int xrdp_mcs_send(struct xrdp_mcs* self)
int xrdp_mcs_disconnect(struct xrdp_mcs* self) int xrdp_mcs_disconnect(struct xrdp_mcs* self)
{ {
int len; int len;
struct stream* s;
xrdp_mcs_init(self, 100); make_stream(s);
s_mark_end(self->out_s); init_stream(s, 8192);
s_pop_layer(self->out_s, mcs_hdr); if (xrdp_mcs_init(self, s) != 0)
len = (self->out_s->end - self->out_s->p) - 8; {
len = len | 0x8000; free_stream(s);
out_uint8(self->out_s, MCS_DPUM << 2);
out_uint16_be(self->out_s, self->userid);
out_uint16_be(self->out_s, MCS_GLOBAL_CHANNEL);
out_uint8(self->out_s, 0x70);
out_uint16_be(self->out_s, len);
if (xrdp_iso_send(self->iso_layer) != 0)
return 1; return 1;
}
s_mark_end(s);
s_pop_layer(s, mcs_hdr);
len = (s->end - s->p) - 8;
len = len | 0x8000;
out_uint8(s, MCS_DPUM << 2);
out_uint16_be(s, self->userid);
out_uint16_be(s, MCS_GLOBAL_CHANNEL);
out_uint8(s, 0x70);
out_uint16_be(s, len);
if (xrdp_iso_send(self->iso_layer, s) != 0)
{
free_stream(s);
return 1;
}
free_stream(s);
return 0; return 0;
} }

18
xrdp/xrdp_orders.c
View File

@ -30,13 +30,15 @@ struct xrdp_orders* xrdp_orders_create(struct xrdp_process* owner)
self = (struct xrdp_orders*)g_malloc(sizeof(struct xrdp_orders), 1); self = (struct xrdp_orders*)g_malloc(sizeof(struct xrdp_orders), 1);
self->pro_layer = owner; self->pro_layer = owner;
self->rdp_layer = owner->rdp_layer; self->rdp_layer = owner->rdp_layer;
self->out_s = &owner->out_s; make_stream(self->out_s);
init_stream(self->out_s, 8192);
return self; return self;
} }
/*****************************************************************************/ /*****************************************************************************/
void xrdp_orders_delete(struct xrdp_orders* self) void xrdp_orders_delete(struct xrdp_orders* self)
{ {
free_stream(self->out_s);
g_free(self); g_free(self);
} }
@ -48,7 +50,8 @@ int xrdp_orders_init(struct xrdp_orders* self)
if (self->order_level == 1) if (self->order_level == 1)
{ {
self->order_count = 0; self->order_count = 0;
if (xrdp_rdp_init_data(self->rdp_layer, 8192) != 0) /* is this big enough */ /* is this big enough */
if (xrdp_rdp_init_data(self->rdp_layer, self->out_s) != 0)
return 1; return 1;
out_uint16_le(self->out_s, RDP_UPDATE_ORDERS); out_uint16_le(self->out_s, RDP_UPDATE_ORDERS);
out_uint8s(self->out_s, 2); /* pad */ out_uint8s(self->out_s, 2); /* pad */
@ -73,7 +76,8 @@ int xrdp_orders_send(struct xrdp_orders* self)
{ {
s_mark_end(self->out_s); s_mark_end(self->out_s);
*((short*)self->order_count_ptr) = self->order_count; *((short*)self->order_count_ptr) = self->order_count;
if (xrdp_rdp_send_data(self->rdp_layer, RDP_DATA_PDU_UPDATE) != 0) if (xrdp_rdp_send_data(self->rdp_layer, self->out_s,
RDP_DATA_PDU_UPDATE) != 0)
rv = 1; rv = 1;
} }
} }
@ -88,7 +92,8 @@ int xrdp_orders_force_send(struct xrdp_orders* self)
{ {
s_mark_end(self->out_s); s_mark_end(self->out_s);
*((short*)self->order_count_ptr) = self->order_count; *((short*)self->order_count_ptr) = self->order_count;
if (xrdp_rdp_send_data(self->rdp_layer, RDP_DATA_PDU_UPDATE) != 0) if (xrdp_rdp_send_data(self->rdp_layer, self->out_s,
RDP_DATA_PDU_UPDATE) != 0)
return 1; return 1;
} }
self->order_count = 0; self->order_count = 0;
@ -891,7 +896,6 @@ int xrdp_orders_mem_blt(struct xrdp_orders* self, int cache_id,
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
/* when a palette gets sent, send the main palette too */ /* when a palette gets sent, send the main palette too */
/* don't need max size here */
int xrdp_orders_send_palette(struct xrdp_orders* self, int* palette, int xrdp_orders_send_palette(struct xrdp_orders* self, int* palette,
int cache_id) int cache_id)
{ {
@ -899,10 +903,8 @@ int xrdp_orders_send_palette(struct xrdp_orders* self, int* palette,
int len; int len;
int i; int i;
/* gota clear any build up orders and send the main palette */
xrdp_orders_force_send(self);
xrdp_wm_send_palette(self->pro_layer->wm); xrdp_wm_send_palette(self->pro_layer->wm);
xrdp_orders_init(self); xrdp_orders_check(self, 2000);
self->order_count++; self->order_count++;
order_flags = RDP_ORDER_STANDARD | RDP_ORDER_SECONDARY; order_flags = RDP_ORDER_STANDARD | RDP_ORDER_SECONDARY;
out_uint8(self->out_s, order_flags); out_uint8(self->out_s, order_flags);

14
xrdp/xrdp_process.c
View File

@ -39,8 +39,6 @@ void xrdp_process_delete(struct xrdp_process* self)
xrdp_rdp_delete(self->rdp_layer); xrdp_rdp_delete(self->rdp_layer);
xrdp_orders_delete(self->orders); xrdp_orders_delete(self->orders);
xrdp_wm_delete(self->wm); xrdp_wm_delete(self->wm);
g_free(self->in_s.data);
g_free(self->out_s.data);
g_free(self); g_free(self);
} }
@ -50,7 +48,9 @@ int xrdp_process_main_loop(struct xrdp_process* self)
int code; int code;
int i; int i;
int cont; int cont;
struct stream* s;
make_stream(s);
self->status = 1; self->status = 1;
self->rdp_layer = xrdp_rdp_create(self); self->rdp_layer = xrdp_rdp_create(self);
g_tcp_set_non_blocking(self->sck); g_tcp_set_non_blocking(self->sck);
@ -61,10 +61,11 @@ int xrdp_process_main_loop(struct xrdp_process* self)
i = g_tcp_select(self->sck); i = g_tcp_select(self->sck);
if (i == 1) if (i == 1)
{ {
init_stream(s, 8192);
cont = 1; cont = 1;
while (cont) while (cont)
{ {
if (xrdp_rdp_recv(self->rdp_layer, &code) != 0) if (xrdp_rdp_recv(self->rdp_layer, s, &code) != 0)
break; break;
DEBUG(("xrdp_process_main_loop code %d\n\r", code)); DEBUG(("xrdp_process_main_loop code %d\n\r", code));
switch (code) switch (code)
@ -75,10 +76,10 @@ int xrdp_process_main_loop(struct xrdp_process* self)
case 0: case 0:
break; break;
case RDP_PDU_CONFIRM_ACTIVE: case RDP_PDU_CONFIRM_ACTIVE:
xrdp_rdp_process_confirm_active(self->rdp_layer); /* 3 */ xrdp_rdp_process_confirm_active(self->rdp_layer, s); /* 3 */
break; break;
case RDP_PDU_DATA: case RDP_PDU_DATA:
if (xrdp_rdp_process_data(self->rdp_layer) != 0) /* 7 */ if (xrdp_rdp_process_data(self->rdp_layer, s) != 0) /* 7 */
{ {
DEBUG(("xrdp_rdp_process_data returned non zero\n\r")); DEBUG(("xrdp_rdp_process_data returned non zero\n\r"));
cont = 0; cont = 0;
@ -90,7 +91,7 @@ int xrdp_process_main_loop(struct xrdp_process* self)
break; break;
} }
if (cont) if (cont)
cont = self->rdp_layer->next_packet < self->rdp_layer->in_s->end; cont = s->next_packet < s->end;
} }
if (cont) /* we must have errored out */ if (cont) /* we must have errored out */
break; break;
@ -115,5 +116,6 @@ int xrdp_process_main_loop(struct xrdp_process* self)
g_tcp_close(self->sck); g_tcp_close(self->sck);
self->status = -1; self->status = -1;
xrdp_listen_delete_pro(self->lis_layer, self); xrdp_listen_delete_pro(self->lis_layer, self);
free_stream(s);
return 0; return 0;
} }

421
xrdp/xrdp_rdp.c
View File

@ -53,8 +53,6 @@ struct xrdp_rdp* xrdp_rdp_create(struct xrdp_process* owner)
self = (struct xrdp_rdp*)g_malloc(sizeof(struct xrdp_rdp), 1); self = (struct xrdp_rdp*)g_malloc(sizeof(struct xrdp_rdp), 1);
self->pro_layer = owner; self->pro_layer = owner;
self->in_s = &owner->in_s;
self->out_s = &owner->out_s;
self->share_id = 66538; self->share_id = 66538;
self->sec_layer = xrdp_sec_create(self); self->sec_layer = xrdp_sec_create(self);
return self; return self;
@ -70,103 +68,104 @@ void xrdp_rdp_delete(struct xrdp_rdp* self)
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_init(struct xrdp_rdp* self, int len) int xrdp_rdp_init(struct xrdp_rdp* self, struct stream* s)
{ {
if (xrdp_sec_init(self->sec_layer, len + 6) != 0) if (xrdp_sec_init(self->sec_layer, s) != 0)
return 1; return 1;
s_push_layer(self->out_s, rdp_hdr, 6); s_push_layer(s, rdp_hdr, 6);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_init_data(struct xrdp_rdp* self, int len) int xrdp_rdp_init_data(struct xrdp_rdp* self, struct stream* s)
{ {
if (xrdp_sec_init(self->sec_layer, len + 18) != 0) if (xrdp_sec_init(self->sec_layer, s) != 0)
return 1; return 1;
s_push_layer(self->out_s, rdp_hdr, 18); s_push_layer(s, rdp_hdr, 18);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_recv(struct xrdp_rdp* self, int* code) int xrdp_rdp_recv(struct xrdp_rdp* self, struct stream* s, int* code)
{ {
int error; int error;
int len; int len;
int pdu_code; int pdu_code;
int chan; int chan;
if (self->next_packet == 0 || self->next_packet >= self->in_s->end) if (s->next_packet == 0 || s->next_packet >= s->end)
{ {
chan = 0; chan = 0;
error = xrdp_sec_recv(self->sec_layer, &chan); error = xrdp_sec_recv(self->sec_layer, s, &chan);
if (error == -1) /* special code for send demand active */ if (error == -1) /* special code for send demand active */
{ {
self->next_packet = 0; s->next_packet = 0;
*code = -1; *code = -1;
return 0; return 0;
} }
if (chan != MCS_GLOBAL_CHANNEL && chan > 0) if (chan != MCS_GLOBAL_CHANNEL && chan > 0)
{ {
self->next_packet = 0; s->next_packet = 0;
*code = 0; *code = 0;
return 0; return 0;
} }
if (error != 0) if (error != 0)
return 1; return 1;
self->next_packet = self->in_s->p; s->next_packet = s->p;
} }
else else
self->in_s->p = self->next_packet; s->p = s->next_packet;
in_uint16_le(self->in_s, len); in_uint16_le(s, len);
if (len == 0x8000) if (len == 0x8000)
{ {
self->next_packet += 8; s->next_packet += 8;
*code = 0; *code = 0;
return 0; return 0;
} }
in_uint16_le(self->in_s, pdu_code); in_uint16_le(s, pdu_code);
*code = pdu_code & 0xf; *code = pdu_code & 0xf;
in_uint8s(self->in_s, 2); /* mcs user id */ in_uint8s(s, 2); /* mcs user id */
self->next_packet += len; s->next_packet += len;
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_send(struct xrdp_rdp* self, int pdu_type) int xrdp_rdp_send(struct xrdp_rdp* self, struct stream* s, int pdu_type)
{ {
int len; int len;
DEBUG(("in xrdp_rdp_send\n\r")); DEBUG(("in xrdp_rdp_send\n\r"));
s_pop_layer(self->out_s, rdp_hdr); s_pop_layer(s, rdp_hdr);
len = self->out_s->end - self->out_s->p; len = s->end - s->p;
out_uint16_le(self->out_s, len); out_uint16_le(s, len);
out_uint16_le(self->out_s, 0x10 | pdu_type); out_uint16_le(s, 0x10 | pdu_type);
out_uint16_le(self->out_s, self->mcs_channel); out_uint16_le(s, self->mcs_channel);
if (xrdp_sec_send(self->sec_layer, 0) != 0) if (xrdp_sec_send(self->sec_layer, s, 0) != 0)
return 1; return 1;
DEBUG(("out xrdp_rdp_send\n\r")); DEBUG(("out xrdp_rdp_send\n\r"));
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_send_data(struct xrdp_rdp* self, int data_pdu_type) int xrdp_rdp_send_data(struct xrdp_rdp* self, struct stream* s,
int data_pdu_type)
{ {
int len; int len;
DEBUG(("in xrdp_rdp_send_data\n\r")); DEBUG(("in xrdp_rdp_send_data\n\r"));
s_pop_layer(self->out_s, rdp_hdr); s_pop_layer(s, rdp_hdr);
len = self->out_s->end - self->out_s->p; len = s->end - s->p;
out_uint16_le(self->out_s, len); out_uint16_le(s, len);
out_uint16_le(self->out_s, 0x10 | RDP_PDU_DATA); out_uint16_le(s, 0x10 | RDP_PDU_DATA);
out_uint16_le(self->out_s, self->mcs_channel); out_uint16_le(s, self->mcs_channel);
out_uint32_le(self->out_s, self->share_id); out_uint32_le(s, self->share_id);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint16_le(self->out_s, len - 14); out_uint16_le(s, len - 14);
out_uint8(self->out_s, data_pdu_type); out_uint8(s, data_pdu_type);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint16_le(self->out_s, 0); out_uint16_le(s, 0);
if (xrdp_sec_send(self->sec_layer, 0) != 0) if (xrdp_sec_send(self->sec_layer, s, 0) != 0)
return 1; return 1;
DEBUG(("out xrdp_rdp_send_data\n\r")); DEBUG(("out xrdp_rdp_send_data\n\r"));
return 0; return 0;
@ -226,135 +225,146 @@ int xrdp_rdp_incoming(struct xrdp_rdp* self)
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_send_demand_active(struct xrdp_rdp* self) int xrdp_rdp_send_demand_active(struct xrdp_rdp* self)
{ {
if (xrdp_rdp_init(self, 512) != 0) struct stream* s;
return 1;
out_uint32_le(self->out_s, self->share_id); make_stream(s);
out_uint32_be(self->out_s, 0x04000401); init_stream(s, 8192);
out_uint32_be(self->out_s, 0x524e5300); if (xrdp_rdp_init(self, s) != 0)
out_uint32_be(self->out_s, 0x08000000); {
out_uint32_be(self->out_s, 0x09000800); free_stream(s);
out_uint16_le(self->out_s, self->mcs_channel); return 1;
out_uint16_be(self->out_s, 0xb5e2); }
out_uint32_le(s, self->share_id);
out_uint32_be(s, 0x04000401);
out_uint32_be(s, 0x524e5300);
out_uint32_be(s, 0x08000000);
out_uint32_be(s, 0x09000800);
out_uint16_le(s, self->mcs_channel);
out_uint16_be(s, 0xb5e2);
/* Output general capability set */ /* Output general capability set */
out_uint16_le(self->out_s, RDP_CAPSET_GENERAL); /* 1 */ out_uint16_le(s, RDP_CAPSET_GENERAL); /* 1 */
out_uint16_le(self->out_s, RDP_CAPLEN_GENERAL); /* 24(0x18) */ out_uint16_le(s, RDP_CAPLEN_GENERAL); /* 24(0x18) */
out_uint16_le(self->out_s, 1); /* OS major type */ out_uint16_le(s, 1); /* OS major type */
out_uint16_le(self->out_s, 3); /* OS minor type */ out_uint16_le(s, 3); /* OS minor type */
out_uint16_le(self->out_s, 0x200); /* Protocol version */ out_uint16_le(s, 0x200); /* Protocol version */
out_uint16_le(self->out_s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
out_uint16_le(self->out_s, 0); /* Compression types */ out_uint16_le(s, 0); /* Compression types */
out_uint16_le(self->out_s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
out_uint16_le(self->out_s, 0); /* Update capability */ out_uint16_le(s, 0); /* Update capability */
out_uint16_le(self->out_s, 0); /* Remote unshare capability */ out_uint16_le(s, 0); /* Remote unshare capability */
out_uint16_le(self->out_s, 0); /* Compression level */ out_uint16_le(s, 0); /* Compression level */
out_uint16_le(self->out_s, 0); /* Pad */ out_uint16_le(s, 0); /* Pad */
/* Output bitmap capability set */ /* Output bitmap capability set */
out_uint16_le(self->out_s, RDP_CAPSET_BITMAP); /* 2 */ out_uint16_le(s, RDP_CAPSET_BITMAP); /* 2 */
out_uint16_le(self->out_s, RDP_CAPLEN_BITMAP); /* 28(0x1c) */ out_uint16_le(s, RDP_CAPLEN_BITMAP); /* 28(0x1c) */
out_uint16_le(self->out_s, self->bpp); /* Preferred BPP */ out_uint16_le(s, self->bpp); /* Preferred BPP */
out_uint16_le(self->out_s, 1); /* Receive 1 BPP */ out_uint16_le(s, 1); /* Receive 1 BPP */
out_uint16_le(self->out_s, 1); /* Receive 4 BPP */ out_uint16_le(s, 1); /* Receive 4 BPP */
out_uint16_le(self->out_s, 1); /* Receive 8 BPP */ out_uint16_le(s, 1); /* Receive 8 BPP */
out_uint16_le(self->out_s, self->width); /* width */ out_uint16_le(s, self->width); /* width */
out_uint16_le(self->out_s, self->height); /* height */ out_uint16_le(s, self->height); /* height */
out_uint16_le(self->out_s, 0); /* Pad */ out_uint16_le(s, 0); /* Pad */
out_uint16_le(self->out_s, 1); /* Allow resize */ out_uint16_le(s, 1); /* Allow resize */
out_uint16_le(self->out_s, 1); /* bitmap compression */ out_uint16_le(s, 1); /* bitmap compression */
out_uint16_le(self->out_s, 0); /* unknown */ out_uint16_le(s, 0); /* unknown */
out_uint16_le(self->out_s, 0); /* unknown */ out_uint16_le(s, 0); /* unknown */
out_uint16_le(self->out_s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
/* Output ? */ /* Output ? */
out_uint16_le(self->out_s, 14); out_uint16_le(s, 14);
out_uint16_le(self->out_s, 4); out_uint16_le(s, 4);
/* Output order capability set */ /* Output order capability set */
out_uint16_le(self->out_s, RDP_CAPSET_ORDER); /* 3 */ out_uint16_le(s, RDP_CAPSET_ORDER); /* 3 */
out_uint16_le(self->out_s, RDP_CAPLEN_ORDER); /* 88(0x58) */ out_uint16_le(s, RDP_CAPLEN_ORDER); /* 88(0x58) */
out_uint8s(self->out_s, 16); out_uint8s(s, 16);
out_uint32_be(self->out_s, 0x40420f00); out_uint32_be(s, 0x40420f00);
out_uint16_le(self->out_s, 1); /* Cache X granularity */ out_uint16_le(s, 1); /* Cache X granularity */
out_uint16_le(self->out_s, 20); /* Cache Y granularity */ out_uint16_le(s, 20); /* Cache Y granularity */
out_uint16_le(self->out_s, 0); /* Pad */ out_uint16_le(s, 0); /* Pad */
out_uint16_le(self->out_s, 1); /* Max order level */ out_uint16_le(s, 1); /* Max order level */
out_uint16_le(self->out_s, 0x2f); /* Number of fonts */ out_uint16_le(s, 0x2f); /* Number of fonts */
out_uint16_le(self->out_s, 0x22); /* Capability flags */ out_uint16_le(s, 0x22); /* Capability flags */
/* caps */ /* caps */
out_uint8(self->out_s, 1); /* dest blt */ out_uint8(s, 1); /* dest blt */
out_uint8(self->out_s, 1); /* pat blt */ out_uint8(s, 1); /* pat blt */
out_uint8(self->out_s, 1); /* screen blt */ out_uint8(s, 1); /* screen blt */
out_uint8(self->out_s, 1); /* memblt */ out_uint8(s, 1); /* memblt */
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint8(self->out_s, 0); out_uint8(s, 0);
out_uint16_le(self->out_s, 0x6a1); out_uint16_le(s, 0x6a1);
out_uint8s(self->out_s, 6); /* ? */ out_uint8s(s, 6); /* ? */
out_uint32_le(self->out_s, 0x0f4240); /* desk save */ out_uint32_le(s, 0x0f4240); /* desk save */
out_uint32_le(self->out_s, 0); /* ? */ out_uint32_le(s, 0); /* ? */
out_uint32_le(self->out_s, 0); /* ? */ out_uint32_le(s, 0); /* ? */
/* Output color cache capability set */ /* Output color cache capability set */
out_uint16_le(self->out_s, RDP_CAPSET_COLCACHE); out_uint16_le(s, RDP_CAPSET_COLCACHE);
out_uint16_le(self->out_s, RDP_CAPLEN_COLCACHE); out_uint16_le(s, RDP_CAPLEN_COLCACHE);
out_uint16_le(self->out_s, 6); /* cache size */ out_uint16_le(s, 6); /* cache size */
out_uint16_le(self->out_s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
/* Output pointer capability set */ /* Output pointer capability set */
out_uint16_le(self->out_s, RDP_CAPSET_POINTER); out_uint16_le(s, RDP_CAPSET_POINTER);
out_uint16_le(self->out_s, RDP_CAPLEN_POINTER); out_uint16_le(s, RDP_CAPLEN_POINTER);
out_uint16_le(self->out_s, 1); /* Colour pointer */ out_uint16_le(s, 1); /* Colour pointer */
out_uint16_le(self->out_s, 0x19); /* Cache size */ out_uint16_le(s, 0x19); /* Cache size */
/* Output ? */ /* Output ? */
out_uint16_le(self->out_s, 0xd); out_uint16_le(s, 0xd);
out_uint16_le(self->out_s, 0x58); /* 88 */ out_uint16_le(s, 0x58); /* 88 */
out_uint8(self->out_s, 1); out_uint8(s, 1);
out_uint8s(self->out_s, 83); out_uint8s(s, 83);
s_mark_end(self->out_s); s_mark_end(s);
if (xrdp_rdp_send(self, RDP_PDU_DEMAND_ACTIVE) != 0) if (xrdp_rdp_send(self, s, RDP_PDU_DEMAND_ACTIVE) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_process_confirm_active(struct xrdp_rdp* self) int xrdp_rdp_process_confirm_active(struct xrdp_rdp* self, struct stream* s)
{ {
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_process_data_pointer(struct xrdp_rdp* self) int xrdp_rdp_process_data_pointer(struct xrdp_rdp* self, struct stream* s)
{ {
return 0; return 0;
} }
@ -410,7 +420,7 @@ int xrdp_rdp_process_input_mouse(struct xrdp_rdp* self, int device_flags,
/*****************************************************************************/ /*****************************************************************************/
/* RDP_DATA_PDU_INPUT */ /* RDP_DATA_PDU_INPUT */
int xrdp_rdp_process_data_input(struct xrdp_rdp* self) int xrdp_rdp_process_data_input(struct xrdp_rdp* self, struct stream* s)
{ {
int num_events; int num_events;
int index; int index;
@ -419,16 +429,16 @@ int xrdp_rdp_process_data_input(struct xrdp_rdp* self)
int param1; int param1;
int param2; int param2;
in_uint16_le(self->in_s, num_events); in_uint16_le(s, num_events);
in_uint8s(self->in_s, 2); /* pad */ in_uint8s(s, 2); /* pad */
DEBUG(("xrdp_rdp_process_data_input %d events\n\r", num_events)) DEBUG(("xrdp_rdp_process_data_input %d events\n\r", num_events))
for (index = 0; index < num_events; index++) for (index = 0; index < num_events; index++)
{ {
in_uint8s(self->in_s, 4); /* time */ in_uint8s(s, 4); /* time */
in_uint16_le(self->in_s, msg_type); in_uint16_le(s, msg_type);
in_uint16_le(self->in_s, device_flags); in_uint16_le(s, device_flags);
in_sint16_le(self->in_s, param1); in_sint16_le(s, param1);
in_sint16_le(self->in_s, param2); in_sint16_le(s, param2);
switch (msg_type) switch (msg_type)
{ {
case RDP_INPUT_SYNCHRONIZE: /* 0 */ case RDP_INPUT_SYNCHRONIZE: /* 0 */
@ -451,38 +461,60 @@ int xrdp_rdp_process_data_input(struct xrdp_rdp* self)
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_send_synchronise(struct xrdp_rdp* self) int xrdp_rdp_send_synchronise(struct xrdp_rdp* self)
{ {
if (xrdp_rdp_init_data(self, 4) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint16_le(self->out_s, 1); }
out_uint16_le(self->out_s, 1002); out_uint16_le(s, 1);
s_mark_end(self->out_s); out_uint16_le(s, 1002);
if (xrdp_rdp_send_data(self, RDP_DATA_PDU_SYNCHRONISE) != 0) s_mark_end(s);
if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_SYNCHRONISE) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_send_control(struct xrdp_rdp* self, int action) int xrdp_rdp_send_control(struct xrdp_rdp* self, int action)
{ {
if (xrdp_rdp_init_data(self, 8) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint16_le(self->out_s, action); }
out_uint16_le(self->out_s, 0); /* userid */ out_uint16_le(s, action);
out_uint32_le(self->out_s, 1002); /* control id */ out_uint16_le(s, 0); /* userid */
s_mark_end(self->out_s); out_uint32_le(s, 1002); /* control id */
if (xrdp_rdp_send_data(self, RDP_DATA_PDU_CONTROL) != 0) s_mark_end(s);
if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_CONTROL) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_process_data_control(struct xrdp_rdp* self) int xrdp_rdp_process_data_control(struct xrdp_rdp* self, struct stream* s)
{ {
int action; int action;
in_uint16_le(self->in_s, action); in_uint16_le(s, action);
in_uint8s(self->in_s, 2); /* user id */ in_uint8s(s, 2); /* user id */
in_uint8s(self->in_s, 4); /* control id */ in_uint8s(s, 4); /* control id */
if (action == RDP_CTL_REQUEST_CONTROL) if (action == RDP_CTL_REQUEST_CONTROL)
{ {
xrdp_rdp_send_synchronise(self); xrdp_rdp_send_synchronise(self);
@ -499,7 +531,7 @@ int xrdp_rdp_process_data_sync(struct xrdp_rdp* self)
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_process_screen_update(struct xrdp_rdp* self) int xrdp_rdp_process_screen_update(struct xrdp_rdp* self, struct stream* s)
{ {
int op; int op;
int left; int left;
@ -508,11 +540,11 @@ int xrdp_rdp_process_screen_update(struct xrdp_rdp* self)
int bottom; int bottom;
struct xrdp_rect rect; struct xrdp_rect rect;
in_uint32_le(self->in_s, op); in_uint32_le(s, op);
in_uint16_le(self->in_s, left); in_uint16_le(s, left);
in_uint16_le(self->in_s, top); in_uint16_le(s, top);
in_uint16_le(self->in_s, right); in_uint16_le(s, right);
in_uint16_le(self->in_s, bottom); in_uint16_le(s, bottom);
xrdp_wm_rect(&rect, left, top, (right - left) + 1, (bottom - top) + 1); xrdp_wm_rect(&rect, left, top, (right - left) + 1, (bottom - top) + 1);
if (self->up_and_running && self->pro_layer->wm != 0) if (self->up_and_running && self->pro_layer->wm != 0)
xrdp_bitmap_invalidate(self->pro_layer->wm->screen, &rect); xrdp_bitmap_invalidate(self->pro_layer->wm->screen, &rect);
@ -522,23 +554,34 @@ int xrdp_rdp_process_screen_update(struct xrdp_rdp* self)
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_send_unknown1(struct xrdp_rdp* self) int xrdp_rdp_send_unknown1(struct xrdp_rdp* self)
{ {
if (xrdp_rdp_init_data(self, 300) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_rdp_init_data(self, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint8a(self->out_s, unknown1, 172); }
s_mark_end(self->out_s); out_uint8a(s, unknown1, 172);
if (xrdp_rdp_send_data(self, 0x28) != 0) s_mark_end(s);
if (xrdp_rdp_send_data(self, s, 0x28) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
int xrdp_rdp_process_data_font(struct xrdp_rdp* self) int xrdp_rdp_process_data_font(struct xrdp_rdp* self, struct stream* s)
{ {
int seq; int seq;
in_uint8s(self->in_s, 2); /* num of fonts */ in_uint8s(s, 2); /* num of fonts */
in_uint8s(self->in_s, 2); // unknown in_uint8s(s, 2); // unknown
in_uint16_le(self->in_s, seq); in_uint16_le(s, seq);
/* 419 client sends Seq 1, then 2 */ /* 419 client sends Seq 1, then 2 */
/* 2600 clients sends only Seq 3 */ /* 2600 clients sends only Seq 3 */
if (seq == 2 || seq == 3) /* after second font message, we are up and */ if (seq == 2 || seq == 3) /* after second font message, we are up and */
@ -551,35 +594,35 @@ int xrdp_rdp_process_data_font(struct xrdp_rdp* self)
/*****************************************************************************/ /*****************************************************************************/
/* RDP_PDU_DATA */ /* RDP_PDU_DATA */
int xrdp_rdp_process_data(struct xrdp_rdp* self) int xrdp_rdp_process_data(struct xrdp_rdp* self, struct stream* s)
{ {
int len; int len;
int data_type; int data_type;
int ctype; int ctype;
int clen; int clen;
in_uint8s(self->in_s, 6); in_uint8s(s, 6);
in_uint16_le(self->in_s, len); in_uint16_le(s, len);
in_uint8(self->in_s, data_type); in_uint8(s, data_type);
in_uint8(self->in_s, ctype); in_uint8(s, ctype);
in_uint16_le(self->in_s, clen); in_uint16_le(s, clen);
DEBUG(("xrdp_rdp_process_data code %d\n\r", data_type)); DEBUG(("xrdp_rdp_process_data code %d\n\r", data_type));
switch (data_type) switch (data_type)
{ {
case RDP_DATA_PDU_POINTER: /* 27 */ case RDP_DATA_PDU_POINTER: /* 27 */
xrdp_rdp_process_data_pointer(self); xrdp_rdp_process_data_pointer(self, s);
break; break;
case RDP_DATA_PDU_INPUT: /* 28 */ case RDP_DATA_PDU_INPUT: /* 28 */
xrdp_rdp_process_data_input(self); xrdp_rdp_process_data_input(self, s);
break; break;
case RDP_DATA_PDU_CONTROL: /* 20 */ case RDP_DATA_PDU_CONTROL: /* 20 */
xrdp_rdp_process_data_control(self); xrdp_rdp_process_data_control(self, s);
break; break;
case RDP_DATA_PDU_SYNCHRONISE: /* 31 */ case RDP_DATA_PDU_SYNCHRONISE: /* 31 */
xrdp_rdp_process_data_sync(self); xrdp_rdp_process_data_sync(self);
break; break;
case 33: /* 33 ?? */ case 33: /* 33 ?? */
xrdp_rdp_process_screen_update(self); xrdp_rdp_process_screen_update(self, s);
break; break;
//case 35: /* 35 ?? this comes when minimuzing a full screen mstsc.exe 2600 */ //case 35: /* 35 ?? this comes when minimuzing a full screen mstsc.exe 2600 */
@ -588,7 +631,7 @@ int xrdp_rdp_process_data(struct xrdp_rdp* self)
return 1; return 1;
break; break;
case RDP_DATA_PDU_FONT2: /* 39 */ case RDP_DATA_PDU_FONT2: /* 39 */
xrdp_rdp_process_data_font(self); xrdp_rdp_process_data_font(self, s);
break; break;
default: default:
g_printf("unknown in xrdp_rdp_process_data %d\n\r", data_type); g_printf("unknown in xrdp_rdp_process_data %d\n\r", data_type);

96
xrdp/xrdp_sec.c
View File

@ -118,8 +118,6 @@ struct xrdp_sec* xrdp_sec_create(struct xrdp_rdp* owner)
self = (struct xrdp_sec*)g_malloc(sizeof(struct xrdp_sec), 1); self = (struct xrdp_sec*)g_malloc(sizeof(struct xrdp_sec), 1);
self->rdp_layer = owner; self->rdp_layer = owner;
self->in_s = owner->in_s;
self->out_s = owner->out_s;
self->rc4_key_size = 1; self->rc4_key_size = 1;
self->decrypt_rc4_info = g_rc4_info_create(); self->decrypt_rc4_info = g_rc4_info_create();
self->encrypt_rc4_info = g_rc4_info_create(); self->encrypt_rc4_info = g_rc4_info_create();
@ -143,11 +141,11 @@ void xrdp_sec_delete(struct xrdp_sec* self)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_sec_init(struct xrdp_sec* self, int len) int xrdp_sec_init(struct xrdp_sec* self, struct stream* s)
{ {
if (xrdp_mcs_init(self->mcs_layer, len + 4) != 0) if (xrdp_mcs_init(self->mcs_layer, s) != 0)
return 1; return 1;
s_push_layer(self->out_s, sec_hdr, 4); s_push_layer(s, sec_hdr, 4);
return 0; return 0;
} }
@ -210,7 +208,7 @@ void xrdp_sec_decrypt(struct xrdp_sec* self, char* data, int len)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_sec_process_logon_info(struct xrdp_sec* self) int xrdp_sec_process_logon_info(struct xrdp_sec* self, struct stream* s)
{ {
int flags; int flags;
int len_domain; int len_domain;
@ -219,8 +217,8 @@ int xrdp_sec_process_logon_info(struct xrdp_sec* self)
int len_program; int len_program;
int len_directory; int len_directory;
in_uint8s(self->in_s, 4); in_uint8s(s, 4);
in_uint32_le(self->in_s, flags); in_uint32_le(s, flags);
DEBUG(("in xrdp_sec_process_logon_info flags $%x\n", flags)); DEBUG(("in xrdp_sec_process_logon_info flags $%x\n", flags));
/* this is the first test that the decrypt is working */ /* this is the first test that the decrypt is working */
if ((flags & RDP_LOGON_NORMAL) != RDP_LOGON_NORMAL) /* 0x33 */ if ((flags & RDP_LOGON_NORMAL) != RDP_LOGON_NORMAL) /* 0x33 */
@ -229,16 +227,16 @@ int xrdp_sec_process_logon_info(struct xrdp_sec* self)
; ;
if (flags & RDP_COMPRESSION) if (flags & RDP_COMPRESSION)
; ;
in_uint16_le(self->in_s, len_domain); in_uint16_le(s, len_domain);
in_uint16_le(self->in_s, len_user); in_uint16_le(s, len_user);
in_uint16_le(self->in_s, len_password); in_uint16_le(s, len_password);
in_uint16_le(self->in_s, len_program); in_uint16_le(s, len_program);
in_uint16_le(self->in_s, len_directory); in_uint16_le(s, len_directory);
in_uint8s(self->in_s, len_domain + 2); in_uint8s(s, len_domain + 2);
in_uint8s(self->in_s, len_user + 2); in_uint8s(s, len_user + 2);
in_uint8s(self->in_s, len_password + 2); in_uint8s(s, len_password + 2);
in_uint8s(self->in_s, len_program + 2); in_uint8s(s, len_program + 2);
in_uint8s(self->in_s, len_directory + 2); in_uint8s(s, len_directory + 2);
return 0; return 0;
} }
@ -246,12 +244,23 @@ int xrdp_sec_process_logon_info(struct xrdp_sec* self)
/* returns error */ /* returns error */
int xrdp_sec_send_lic_initial(struct xrdp_sec* self) int xrdp_sec_send_lic_initial(struct xrdp_sec* self)
{ {
if (xrdp_mcs_init(self->mcs_layer, 322) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_mcs_init(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint8a(self->out_s, lic1, 322); }
s_mark_end(self->out_s); out_uint8a(s, lic1, 322);
if (xrdp_mcs_send(self->mcs_layer) != 0) s_mark_end(s);
if (xrdp_mcs_send(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
@ -259,12 +268,23 @@ int xrdp_sec_send_lic_initial(struct xrdp_sec* self)
/* returns error */ /* returns error */
int xrdp_sec_send_lic_response(struct xrdp_sec* self) int xrdp_sec_send_lic_response(struct xrdp_sec* self)
{ {
if (xrdp_mcs_init(self->mcs_layer, 20) != 0) struct stream* s;
make_stream(s);
init_stream(s, 8192);
if (xrdp_mcs_init(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
out_uint8a(self->out_s, lic2, 20); }
s_mark_end(self->out_s); out_uint8a(s, lic2, 20);
if (xrdp_mcs_send(self->mcs_layer) != 0) s_mark_end(s);
if (xrdp_mcs_send(self->mcs_layer, s) != 0)
{
free_stream(s);
return 1; return 1;
}
free_stream(s);
return 0; return 0;
} }
@ -388,25 +408,25 @@ void xrdp_sec_establish_keys(struct xrdp_sec* self)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_sec_recv(struct xrdp_sec* self, int* chan) int xrdp_sec_recv(struct xrdp_sec* self, struct stream* s, int* chan)
{ {
int flags; int flags;
int len; int len;
DEBUG((" in xrdp_sec_recv\n\r")); DEBUG((" in xrdp_sec_recv\n\r"));
if (xrdp_mcs_recv(self->mcs_layer, chan) != 0) if (xrdp_mcs_recv(self->mcs_layer, s, chan) != 0)
return 1; return 1;
in_uint32_le(self->in_s, flags); in_uint32_le(s, flags);
DEBUG((" in xrdp_sec_recv flags $%x\n\r", flags)); DEBUG((" in xrdp_sec_recv flags $%x\n\r", flags));
if (flags & SEC_ENCRYPT) /* 0x08 */ if (flags & SEC_ENCRYPT) /* 0x08 */
{ {
in_uint8s(self->in_s, 8); /* signature */ in_uint8s(s, 8); /* signature */
xrdp_sec_decrypt(self, self->in_s->p, self->in_s->end - self->in_s->p); xrdp_sec_decrypt(self, s->p, s->end - s->p);
} }
if (flags & SEC_CLIENT_RANDOM) /* 0x01 */ if (flags & SEC_CLIENT_RANDOM) /* 0x01 */
{ {
in_uint32_le(self->in_s, len); in_uint32_le(s, len);
in_uint8a(self->in_s, self->client_crypt_random, 64); in_uint8a(s, self->client_crypt_random, 64);
xrdp_sec_rsa_op(self->client_random, self->client_crypt_random, xrdp_sec_rsa_op(self->client_random, self->client_crypt_random,
pub_mod, pri_exp); pub_mod, pri_exp);
xrdp_sec_establish_keys(self); xrdp_sec_establish_keys(self);
@ -415,7 +435,7 @@ int xrdp_sec_recv(struct xrdp_sec* self, int* chan)
} }
if (flags & SEC_LOGON_INFO) /* 0x40 */ if (flags & SEC_LOGON_INFO) /* 0x40 */
{ {
if (xrdp_sec_process_logon_info(self) != 0) if (xrdp_sec_process_logon_info(self, s) != 0)
return 1; return 1;
if (xrdp_sec_send_lic_initial(self) != 0) if (xrdp_sec_send_lic_initial(self) != 0)
return 1; return 1;
@ -435,12 +455,12 @@ int xrdp_sec_recv(struct xrdp_sec* self, int* chan)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
/* TODO needs outgoing encryption */ /* TODO needs outgoing encryption */
int xrdp_sec_send(struct xrdp_sec* self, int flags) int xrdp_sec_send(struct xrdp_sec* self, struct stream* s, int flags)
{ {
DEBUG((" in xrdp_sec_send\n\r")); DEBUG((" in xrdp_sec_send\n\r"));
s_pop_layer(self->out_s, sec_hdr); s_pop_layer(s, sec_hdr);
out_uint32_le(self->out_s, flags); out_uint32_le(s, flags);
if (xrdp_mcs_send(self->mcs_layer) != 0) if (xrdp_mcs_send(self->mcs_layer, s) != 0)
return 1; return 1;
DEBUG((" out xrdp_sec_send\n\r")); DEBUG((" out xrdp_sec_send\n\r"));
return 0; return 0;

20
xrdp/xrdp_tcp.c
View File

@ -28,8 +28,6 @@ struct xrdp_tcp* xrdp_tcp_create(struct xrdp_iso* owner)
self = (struct xrdp_tcp*)g_malloc(sizeof(struct xrdp_tcp), 1); self = (struct xrdp_tcp*)g_malloc(sizeof(struct xrdp_tcp), 1);
self->iso_layer = owner; self->iso_layer = owner;
self->in_s = owner->in_s;
self->out_s = owner->out_s;
/* get sck from xrdp_process */ /* get sck from xrdp_process */
self->sck = owner->mcs_layer->sec_layer->rdp_layer->pro_layer->sck; self->sck = owner->mcs_layer->sec_layer->rdp_layer->pro_layer->sck;
return self; return self;
@ -44,25 +42,25 @@ void xrdp_tcp_delete(struct xrdp_tcp* self)
/*****************************************************************************/ /*****************************************************************************/
/* get out stream ready for data */ /* get out stream ready for data */
/* returns error */ /* returns error */
int xrdp_tcp_init(struct xrdp_tcp* self, int len) int xrdp_tcp_init(struct xrdp_tcp* self, struct stream* s)
{ {
init_stream(self->out_s, len); init_stream(s, 8192);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_tcp_recv(struct xrdp_tcp* self, int len) int xrdp_tcp_recv(struct xrdp_tcp* self, struct stream* s, int len)
{ {
int rcvd; int rcvd;
DEBUG((" in xrdp_tcp_recv, gota get %d bytes\n", len)) DEBUG((" in xrdp_tcp_recv, gota get %d bytes\n", len))
init_stream(self->in_s, len); init_stream(s, len);
while (len > 0) while (len > 0)
{ {
if (g_is_term()) if (g_is_term())
return 1; return 1;
rcvd = g_tcp_recv(self->sck, self->in_s->end, len, 0); rcvd = g_tcp_recv(self->sck, s->end, len, 0);
if (rcvd == -1) if (rcvd == -1)
{ {
if (g_tcp_last_error_would_block(self->sck)) if (g_tcp_last_error_would_block(self->sck))
@ -80,7 +78,7 @@ int xrdp_tcp_recv(struct xrdp_tcp* self, int len)
} }
else else
{ {
self->in_s->end += rcvd; s->end += rcvd;
len -= rcvd; len -= rcvd;
} }
} }
@ -89,20 +87,20 @@ int xrdp_tcp_recv(struct xrdp_tcp* self, int len)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int xrdp_tcp_send(struct xrdp_tcp* self) int xrdp_tcp_send(struct xrdp_tcp* self, struct stream* s)
{ {
int len; int len;
int total; int total;
int sent; int sent;
len = self->out_s->end - self->out_s->data; len = s->end - s->data;
DEBUG((" in xrdp_tcp_send, gota send %d bytes\n\r", len)) DEBUG((" in xrdp_tcp_send, gota send %d bytes\n\r", len))
total = 0; total = 0;
while (total < len) while (total < len)
{ {
if (g_is_term()) if (g_is_term())
return 1; return 1;
sent = g_tcp_send(self->sck, self->out_s->data + total, len - total, 0); sent = g_tcp_send(self->sck, s->data + total, len - total, 0);
if (sent == -1) if (sent == -1)
{ {
if (g_tcp_last_error_would_block(self->sck)) if (g_tcp_last_error_would_block(self->sck))

14
xrdp/xrdp_types.h
View File

@ -91,16 +91,12 @@ struct xrdp_pen
struct xrdp_tcp struct xrdp_tcp
{ {
int sck; int sck;
struct stream* in_s;
struct stream* out_s;
struct xrdp_iso* iso_layer; /* owner */ struct xrdp_iso* iso_layer; /* owner */
}; };
/* iso */ /* iso */
struct xrdp_iso struct xrdp_iso
{ {
struct stream* in_s;
struct stream* out_s;
struct xrdp_mcs* mcs_layer; /* owner */ struct xrdp_mcs* mcs_layer; /* owner */
struct xrdp_tcp* tcp_layer; struct xrdp_tcp* tcp_layer;
}; };
@ -108,8 +104,6 @@ struct xrdp_iso
/* mcs */ /* mcs */
struct xrdp_mcs struct xrdp_mcs
{ {
struct stream* in_s;
struct stream* out_s;
struct xrdp_sec* sec_layer; /* owner */ struct xrdp_sec* sec_layer; /* owner */
struct xrdp_iso* iso_layer; struct xrdp_iso* iso_layer;
int userid; int userid;
@ -121,8 +115,6 @@ struct xrdp_mcs
/* sec */ /* sec */
struct xrdp_sec struct xrdp_sec
{ {
struct stream* in_s;
struct stream* out_s;
struct xrdp_rdp* rdp_layer; /* owner */ struct xrdp_rdp* rdp_layer; /* owner */
struct xrdp_mcs* mcs_layer; struct xrdp_mcs* mcs_layer;
char server_random[32]; char server_random[32];
@ -146,11 +138,8 @@ struct xrdp_sec
/* rdp */ /* rdp */
struct xrdp_rdp struct xrdp_rdp
{ {
struct stream* in_s;
struct stream* out_s;
struct xrdp_process* pro_layer; /* owner */ struct xrdp_process* pro_layer; /* owner */
struct xrdp_sec* sec_layer; struct xrdp_sec* sec_layer;
char* next_packet;
int share_id; int share_id;
int mcs_channel; int mcs_channel;
int bpp; int bpp;
@ -257,7 +246,6 @@ struct xrdp_wm
struct xrdp_bitmap* screen; struct xrdp_bitmap* screen;
struct xrdp_orders* orders; struct xrdp_orders* orders;
struct xrdp_painter* painter; struct xrdp_painter* painter;
struct stream* out_s;
struct xrdp_rdp* rdp_layer; struct xrdp_rdp* rdp_layer;
struct xrdp_cache* cache; struct xrdp_cache* cache;
int palette[256]; int palette[256];
@ -296,8 +284,6 @@ struct xrdp_process
int status; int status;
int sck; int sck;
int term; int term;
struct stream in_s;
struct stream out_s;
struct xrdp_listen* lis_layer; /* owner */ struct xrdp_listen* lis_layer; /* owner */
struct xrdp_rdp* rdp_layer; struct xrdp_rdp* rdp_layer;
/* create these when up and running */ /* create these when up and running */

161
xrdp/xrdp_wm.c
View File

@ -35,7 +35,6 @@ struct xrdp_wm* xrdp_wm_create(struct xrdp_process* owner)
self->pro_layer = owner; self->pro_layer = owner;
self->orders = owner->orders; self->orders = owner->orders;
self->painter = xrdp_painter_create(self); self->painter = xrdp_painter_create(self);
self->out_s = &owner->out_s;
self->rdp_layer = owner->rdp_layer; self->rdp_layer = owner->rdp_layer;
self->cache = xrdp_cache_create(self, self->orders); self->cache = xrdp_cache_create(self, self->orders);
return self; return self;
@ -57,21 +56,25 @@ int xrdp_wm_send_palette(struct xrdp_wm* self)
{ {
int i; int i;
int color; int color;
struct stream* s;
xrdp_rdp_init_data(self->rdp_layer, 776); make_stream(s);
out_uint16_le(self->out_s, RDP_UPDATE_PALETTE); init_stream(s, 8192);
out_uint16_le(self->out_s, 0); xrdp_rdp_init_data(self->rdp_layer, s);
out_uint16_le(self->out_s, 256); /* # of colors */ out_uint16_le(s, RDP_UPDATE_PALETTE);
out_uint16_le(self->out_s, 0); out_uint16_le(s, 0);
out_uint16_le(s, 256); /* # of colors */
out_uint16_le(s, 0);
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
color = self->palette[i]; color = self->palette[i];
out_uint8(self->out_s, color >> 16); out_uint8(s, color >> 16);
out_uint8(self->out_s, color >> 8); out_uint8(s, color >> 8);
out_uint8(self->out_s, color); out_uint8(s, color);
} }
s_mark_end(self->out_s); s_mark_end(s);
xrdp_rdp_send_data(self->rdp_layer, RDP_DATA_PDU_UPDATE); xrdp_rdp_send_data(self->rdp_layer, s, RDP_DATA_PDU_UPDATE);
free_stream(s);
return 0; return 0;
} }
@ -86,7 +89,10 @@ int xrdp_wm_send_bitmap(struct xrdp_wm* self, struct xrdp_bitmap* bitmap,
int total_lines; int total_lines;
int lines_sending; int lines_sending;
char* p; char* p;
struct stream* s;
make_stream(s);
init_stream(s, 8192);
data_size = bitmap->width * bitmap->height * ((bitmap->bpp + 7) / 8); data_size = bitmap->width * bitmap->height * ((bitmap->bpp + 7) / 8);
line_size = bitmap->width * ((bitmap->bpp + 7) / 8); line_size = bitmap->width * ((bitmap->bpp + 7) / 8);
total_lines = data_size / line_size; total_lines = data_size / line_size;
@ -97,21 +103,21 @@ int xrdp_wm_send_bitmap(struct xrdp_wm* self, struct xrdp_bitmap* bitmap,
lines_sending = total_lines; lines_sending = total_lines;
while (i < total_lines) while (i < total_lines)
{ {
xrdp_rdp_init_data(self->rdp_layer, 8192); xrdp_rdp_init_data(self->rdp_layer, s);
out_uint16_le(self->out_s, RDP_UPDATE_BITMAP); out_uint16_le(s, RDP_UPDATE_BITMAP);
out_uint16_le(self->out_s, 1); /* num updates */ out_uint16_le(s, 1); /* num updates */
out_uint16_le(self->out_s, x); out_uint16_le(s, x);
out_uint16_le(self->out_s, y + i); out_uint16_le(s, y + i);
out_uint16_le(self->out_s, (x + cx) - 1); out_uint16_le(s, (x + cx) - 1);
out_uint16_le(self->out_s, (y + i + cy) - 1); out_uint16_le(s, (y + i + cy) - 1);
out_uint16_le(self->out_s, bitmap->width); out_uint16_le(s, bitmap->width);
out_uint16_le(self->out_s, lines_sending); out_uint16_le(s, lines_sending);
out_uint16_le(self->out_s, bitmap->bpp); /* bpp */ out_uint16_le(s, bitmap->bpp); /* bpp */
out_uint16_le(self->out_s, 0); /* compress */ out_uint16_le(s, 0); /* compress */
out_uint16_le(self->out_s, line_size * lines_sending); /* bufsize */ out_uint16_le(s, line_size * lines_sending); /* bufsize */
out_uint8a(self->out_s, p, line_size * lines_sending); out_uint8a(s, p, line_size * lines_sending);
s_mark_end(self->out_s); s_mark_end(s);
xrdp_rdp_send_data(self->rdp_layer, RDP_DATA_PDU_UPDATE); xrdp_rdp_send_data(self->rdp_layer, s, RDP_DATA_PDU_UPDATE);
p = p + line_size * lines_sending; p = p + line_size * lines_sending;
i = i + lines_sending; i = i + lines_sending;
if (i + lines_sending > total_lines) if (i + lines_sending > total_lines)
@ -119,6 +125,7 @@ int xrdp_wm_send_bitmap(struct xrdp_wm* self, struct xrdp_bitmap* bitmap,
if (lines_sending <= 0) if (lines_sending <= 0)
break; break;
} }
free_stream(s);
return 0; return 0;
} }
@ -262,12 +269,17 @@ int xrdp_wm_login_notify(struct xrdp_bitmap* wnd,
/*****************************************************************************/ /*****************************************************************************/
int xrdp_set_cursor(struct xrdp_wm* self, int cache_idx) int xrdp_set_cursor(struct xrdp_wm* self, int cache_idx)
{ {
xrdp_rdp_init_data(self->rdp_layer, 8000); struct stream* s;
out_uint16_le(self->out_s, RDP_POINTER_CACHED);
out_uint16_le(self->out_s, 0); /* pad */ make_stream(s);
out_uint16_le(self->out_s, cache_idx); /* cache_idx */ init_stream(s, 8192);
s_mark_end(self->out_s); xrdp_rdp_init_data(self->rdp_layer, s);
xrdp_rdp_send_data(self->rdp_layer, RDP_DATA_PDU_POINTER); out_uint16_le(s, RDP_POINTER_CACHED);
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, cache_idx); /* cache_idx */
s_mark_end(s);
xrdp_rdp_send_data(self->rdp_layer, s, RDP_DATA_PDU_POINTER);
free_stream(s);
return 0; return 0;
} }
@ -313,68 +325,75 @@ int xrdp_send_cursor(struct xrdp_wm* self, char* file_name, int cache_idx)
int rv; int rv;
int pixel; int pixel;
int palette[16]; int palette[16];
struct stream* fs;
struct stream* s; struct stream* s;
rv = 1; rv = 1;
s = (struct stream*)g_malloc(sizeof(struct stream), 1); make_stream(s);
init_stream(s, 8001); init_stream(s, 8192);
make_stream(fs);
init_stream(fs, 8192);
fd = g_file_open(file_name); fd = g_file_open(file_name);
g_file_read(fd, s->data, 8000); g_file_read(fd, fs->data, 8192);
g_file_close(fd); g_file_close(fd);
in_uint8s(s, 6); in_uint8s(fs, 6);
in_uint8(s, w); in_uint8(fs, w);
in_uint8(s, h); in_uint8(fs, h);
in_uint8s(s, 2); in_uint8s(fs, 2);
in_uint16_le(s, x); in_uint16_le(fs, x);
in_uint16_le(s, y); in_uint16_le(fs, y);
in_uint8s(s, 22); in_uint8s(fs, 22);
in_uint8(s, bpp); in_uint8(fs, bpp);
in_uint8s(s, 25); in_uint8s(fs, 25);
if (w == 32 && h == 32) if (w == 32 && h == 32)
{ {
xrdp_rdp_init_data(self->rdp_layer, 8000); xrdp_rdp_init_data(self->rdp_layer, s);
out_uint16_le(self->out_s, RDP_POINTER_COLOR); out_uint16_le(s, RDP_POINTER_COLOR);
out_uint16_le(self->out_s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
out_uint16_le(self->out_s, cache_idx); /* cache_idx */ out_uint16_le(s, cache_idx); /* cache_idx */
out_uint16_le(self->out_s, x); out_uint16_le(s, x);
out_uint16_le(self->out_s, y); out_uint16_le(s, y);
out_uint16_le(self->out_s, w); out_uint16_le(s, w);
out_uint16_le(self->out_s, h); out_uint16_le(s, h);
out_uint16_le(self->out_s, 128); out_uint16_le(s, 128);
out_uint16_le(self->out_s, 3072); out_uint16_le(s, 3072);
if (bpp == 1) if (bpp == 1)
{ {
in_uint8a(s, palette, 8); in_uint8a(fs, palette, 8);
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
{
for (j = 0; j < 32; j++) for (j = 0; j < 32; j++)
{ {
pixel = palette[xrdp_wm_get_pixel(s->p, j, i, 32, 1)]; pixel = palette[xrdp_wm_get_pixel(fs->p, j, i, 32, 1)];
out_uint8(self->out_s, pixel); out_uint8(s, pixel);
out_uint8(self->out_s, pixel >> 8); out_uint8(s, pixel >> 8);
out_uint8(self->out_s, pixel >> 16); out_uint8(s, pixel >> 16);
} }
in_uint8s(s, 128); }
in_uint8s(fs, 128);
} }
else if (bpp == 4) else if (bpp == 4)
{ {
in_uint8a(s, palette, 64); in_uint8a(fs, palette, 64);
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
{
for (j = 0; j < 32; j++) for (j = 0; j < 32; j++)
{ {
pixel = palette[xrdp_wm_get_pixel(s->p, j, i, 32, 4)]; pixel = palette[xrdp_wm_get_pixel(fs->p, j, i, 32, 4)];
out_uint8(self->out_s, pixel); out_uint8(s, pixel);
out_uint8(self->out_s, pixel >> 8); out_uint8(s, pixel >> 8);
out_uint8(self->out_s, pixel >> 16); out_uint8(s, pixel >> 16);
} }
in_uint8s(s, 512);
} }
out_uint8a(self->out_s, s->p, 128); /* mask */ in_uint8s(fs, 512);
s_mark_end(self->out_s); }
xrdp_rdp_send_data(self->rdp_layer, RDP_DATA_PDU_POINTER); out_uint8a(s, fs->p, 128); /* mask */
s_mark_end(s);
xrdp_rdp_send_data(self->rdp_layer, s, RDP_DATA_PDU_POINTER);
rv = 0; rv = 0;
} }
g_free(s->data); free_stream(s);
g_free(s); free_stream(fs);
return rv; return rv;
} }