/** * xrdp: A Remote Desktop Protocol server. * * Copyright (C) Jay Sorg 2004-2013 * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * librdp rdp layer */ #include "rdp.h" #ifndef NULL #define NULL 0 #endif /*****************************************************************************/ struct rdp_rdp *APP_CC rdp_rdp_create(struct mod *owner) { struct rdp_rdp *self; self = (struct rdp_rdp *)g_malloc(sizeof(struct rdp_rdp), 1); self->mod = owner; self->sec_layer = rdp_sec_create(self); self->bitmap_compression = 1; self->bitmap_cache = 1; self->desktop_save = 0; self->orders = rdp_orders_create(self); self->rec_mode = 0; return self; } /*****************************************************************************/ void APP_CC rdp_rdp_delete(struct rdp_rdp *self) { if (self == 0) { return; } rdp_orders_delete(self->orders); rdp_sec_delete(self->sec_layer); if (self->rec_fd != 0) { g_file_close(self->rec_fd); self->rec_fd = 0; } g_free(self); } /******************************************************************************/ /* Initialise an RDP packet */ int APP_CC rdp_rdp_init(struct rdp_rdp *self, struct stream *s) { if (rdp_sec_init(self->sec_layer, s, SEC_ENCRYPT) != 0) { return 1; } s_push_layer(s, rdp_hdr, 6); return 0; } /******************************************************************************/ /* Send an RDP packet */ int APP_CC rdp_rdp_send(struct rdp_rdp *self, struct stream *s, int pdu_type) { int len; int sec_flags; s_pop_layer(s, rdp_hdr); len = s->end - s->p; out_uint16_le(s, len); out_uint16_le(s, pdu_type | 0x10); out_uint16_le(s, self->sec_layer->mcs_layer->userid); sec_flags = SEC_ENCRYPT; if (rdp_sec_send(self->sec_layer, s, sec_flags) != 0) { return 1; } return 0; } /******************************************************************************/ /* Initialise an RDP data packet */ int APP_CC rdp_rdp_init_data(struct rdp_rdp *self, struct stream *s) { if (rdp_sec_init(self->sec_layer, s, SEC_ENCRYPT) != 0) { return 1; } s_push_layer(s, rdp_hdr, 18); return 0; } /******************************************************************************/ /* Send an RDP data packet */ int APP_CC rdp_rdp_send_data(struct rdp_rdp *self, struct stream *s, int pdu_data_type) { int len; int sec_flags; s_pop_layer(s, rdp_hdr); len = s->end - s->p; out_uint16_le(s, len); out_uint16_le(s, RDP_PDU_DATA | 0x10); out_uint16_le(s, self->sec_layer->mcs_layer->userid); out_uint32_le(s, self->share_id); out_uint8(s, 0); out_uint8(s, 1); out_uint16_le(s, len - 14); out_uint8(s, pdu_data_type); out_uint8(s, 0); /* compress type */ out_uint16_le(s, 0); /* compress len */ sec_flags = SEC_ENCRYPT; if (rdp_sec_send(self->sec_layer, s, sec_flags) != 0) { return 1; } return 0; } /******************************************************************************/ /* Output general capability set */ static int APP_CC rdp_rdp_out_general_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_GENERAL); out_uint16_le(s, RDP_CAPLEN_GENERAL); out_uint16_le(s, 1); /* OS major type */ out_uint16_le(s, 3); /* OS minor type */ out_uint16_le(s, 0x200); /* Protocol version */ out_uint16_le(s, 0); /* Pad */ out_uint16_le(s, 0); /* Compression types */ out_uint16_le(s, self->use_rdp5 ? 0x40d : 0); out_uint16_le(s, 0); /* Update capability */ out_uint16_le(s, 0); /* Remote unshare capability */ out_uint16_le(s, 0); /* Compression level */ out_uint16_le(s, 0); /* Pad */ return 0; } /******************************************************************************/ /* Output bitmap capability set */ static int APP_CC rdp_rdp_out_bitmap_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_BITMAP); out_uint16_le(s, RDP_CAPLEN_BITMAP); out_uint16_le(s, self->mod->rdp_bpp); /* Preferred BPP */ out_uint16_le(s, 1); /* Receive 1 BPP */ out_uint16_le(s, 1); /* Receive 4 BPP */ out_uint16_le(s, 1); /* Receive 8 BPP */ out_uint16_le(s, 800); /* Desktop width */ out_uint16_le(s, 600); /* Desktop height */ out_uint16_le(s, 0); /* Pad */ out_uint16_le(s, 1); /* Allow resize */ out_uint16_le(s, self->bitmap_compression); /* Support compression */ out_uint16_le(s, 0); /* Unknown */ out_uint16_le(s, 1); /* Unknown */ out_uint16_le(s, 0); /* Pad */ return 0; } /******************************************************************************/ /* Output order capability set */ static int APP_CC rdp_rdp_out_order_caps(struct rdp_rdp *self, struct stream *s) { char order_caps[32]; g_memset(order_caps, 0, 32); order_caps[0] = 1; /* dest blt */ order_caps[1] = 1; /* pat blt */ order_caps[2] = 1; /* screen blt */ order_caps[3] = self->bitmap_cache; /* memblt */ order_caps[4] = 0; /* triblt */ order_caps[8] = 1; /* line */ order_caps[9] = 1; /* line */ order_caps[10] = 1; /* rect */ order_caps[11] = self->desktop_save; /* desksave */ order_caps[13] = 1; /* memblt another above */ order_caps[14] = 1; /* triblt another above */ order_caps[20] = self->polygon_ellipse_orders; /* polygon */ order_caps[21] = self->polygon_ellipse_orders; /* polygon2 */ order_caps[22] = 0; /* todo polyline */ order_caps[25] = self->polygon_ellipse_orders; /* ellipse */ order_caps[26] = self->polygon_ellipse_orders; /* ellipse2 */ order_caps[27] = 1; /* text2 */ out_uint16_le(s, RDP_CAPSET_ORDER); out_uint16_le(s, RDP_CAPLEN_ORDER); out_uint8s(s, 20); /* Terminal desc, pad */ out_uint16_le(s, 1); /* Cache X granularity */ out_uint16_le(s, 20); /* Cache Y granularity */ out_uint16_le(s, 0); /* Pad */ out_uint16_le(s, 1); /* Max order level */ out_uint16_le(s, 0x147); /* Number of fonts */ out_uint16_le(s, 0x2a); /* Capability flags */ out_uint8p(s, order_caps, 32); /* Orders supported */ out_uint16_le(s, 0x6a1); /* Text capability flags */ out_uint8s(s, 6); /* Pad */ out_uint32_le(s, self->desktop_save * 0x38400); /* Desktop cache size */ out_uint32_le(s, 0); /* Unknown */ out_uint32_le(s, 0x4e4); /* Unknown */ return 0; } /******************************************************************************/ /* Output bitmap cache capability set */ static int APP_CC rdp_rdp_out_bmpcache_caps(struct rdp_rdp *self, struct stream *s) { int Bpp = 0; out_uint16_le(s, RDP_CAPSET_BMPCACHE); out_uint16_le(s, RDP_CAPLEN_BMPCACHE); Bpp = (self->mod->rdp_bpp + 7) / 8; out_uint8s(s, 24); /* unused */ out_uint16_le(s, 0x258); /* entries */ out_uint16_le(s, 0x100 * Bpp); /* max cell size */ out_uint16_le(s, 0x12c); /* entries */ out_uint16_le(s, 0x400 * Bpp); /* max cell size */ out_uint16_le(s, 0x106); /* entries */ out_uint16_le(s, 0x1000 * Bpp); /* max cell size */ return 0; } /******************************************************************************/ /* Output control capability set */ static int APP_CC rdp_rdp_out_control_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_CONTROL); out_uint16_le(s, RDP_CAPLEN_CONTROL); out_uint16_le(s, 0); /* Control capabilities */ out_uint16_le(s, 0); /* Remote detach */ out_uint16_le(s, 2); /* Control interest */ out_uint16_le(s, 2); /* Detach interest */ return 0; } /******************************************************************************/ /* Output activation capability set */ static int APP_CC rdp_rdp_out_activate_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_ACTIVATE); out_uint16_le(s, RDP_CAPLEN_ACTIVATE); out_uint16_le(s, 0); /* Help key */ out_uint16_le(s, 0); /* Help index key */ out_uint16_le(s, 0); /* Extended help key */ out_uint16_le(s, 0); /* Window activate */ return 0; } /******************************************************************************/ /* Output pointer capability set */ static int APP_CC rdp_rdp_out_pointer_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_POINTER); out_uint16_le(s, RDP_CAPLEN_POINTER_MONO); out_uint16_le(s, 0); /* Color pointer */ out_uint16_le(s, 20); /* Cache size */ return 0; } /******************************************************************************/ /* Output share capability set */ static int APP_CC rdp_rdp_out_share_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_SHARE); out_uint16_le(s, RDP_CAPLEN_SHARE); out_uint16_le(s, 0); /* userid */ out_uint16_le(s, 0); /* pad */ return 0; } /******************************************************************************/ /* Output color cache capability set */ static int APP_CC rdp_rdp_out_colcache_caps(struct rdp_rdp *self, struct stream *s) { out_uint16_le(s, RDP_CAPSET_COLCACHE); out_uint16_le(s, RDP_CAPLEN_COLCACHE); out_uint16_le(s, 6); /* cache size */ out_uint16_le(s, 0); /* pad */ return 0; } static const unsigned char caps_0x0d[] = { 0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const unsigned char caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 }; static const unsigned char caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 }; static const unsigned char caps_0x10[] = { 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00, 0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00 }; /******************************************************************************/ /* Output unknown capability sets */ static int APP_CC rdp_rdp_out_unknown_caps(struct rdp_rdp *self, struct stream *s, int id, int length, const unsigned char *caps) { out_uint16_le(s, id); out_uint16_le(s, length); out_uint8p(s, caps, length - 4); return 0; } #define RDP5_FLAG 0x0030 /******************************************************************************/ /* Send a confirm active PDU */ static int APP_CC rdp_rdp_send_confirm_active(struct rdp_rdp *self, struct stream *s) { int sec_flags; int caplen; sec_flags = SEC_ENCRYPT; //sec_flags = RDP5_FLAG | SEC_ENCRYPT; caplen = RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER + RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE + RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL + RDP_CAPLEN_POINTER_MONO + RDP_CAPLEN_SHARE + 0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */ + 4 /* w2k fix, why? */ ; if (rdp_sec_init(self->sec_layer, s, sec_flags) != 0) { return 1; } out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE)); out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10)); /* Version 1 */ out_uint16_le(s, (self->sec_layer->mcs_layer->userid + 1001)); out_uint32_le(s, self->share_id); out_uint16_le(s, 0x3ea); /* userid */ out_uint16_le(s, sizeof(RDP_SOURCE)); out_uint16_le(s, caplen); out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE)); out_uint16_le(s, 0xd); /* num_caps */ out_uint8s(s, 2); /* pad */ rdp_rdp_out_general_caps(self, s); rdp_rdp_out_bitmap_caps(self, s); rdp_rdp_out_order_caps(self, s); rdp_rdp_out_bmpcache_caps(self, s); rdp_rdp_out_colcache_caps(self, s); rdp_rdp_out_activate_caps(self, s); rdp_rdp_out_control_caps(self, s); rdp_rdp_out_pointer_caps(self, s); rdp_rdp_out_share_caps(self, s); rdp_rdp_out_unknown_caps(self, s, 0x0d, 0x58, caps_0x0d); /* international? */ rdp_rdp_out_unknown_caps(self, s, 0x0c, 0x08, caps_0x0c); rdp_rdp_out_unknown_caps(self, s, 0x0e, 0x08, caps_0x0e); rdp_rdp_out_unknown_caps(self, s, 0x10, 0x34, caps_0x10); /* glyph cache? */ s_mark_end(s); if (rdp_sec_send(self->sec_layer, s, sec_flags) != 0) { return 1; } return 0; } /******************************************************************************/ /* Process a color pointer PDU */ static int APP_CC rdp_rdp_process_color_pointer_pdu(struct rdp_rdp *self, struct stream *s) { unsigned int cache_idx; unsigned int dlen; unsigned int mlen; struct rdp_cursor *cursor; in_uint16_le(s, cache_idx); if (cache_idx >= sizeof(self->cursors) / sizeof(cursor)) { return 1; } /* there are only 32 cursors */ if (cache_idx > 31) { return 1; } cursor = self->cursors + cache_idx; in_uint16_le(s, cursor->x); in_uint16_le(s, cursor->y); in_uint16_le(s, cursor->width); in_uint16_le(s, cursor->height); in_uint16_le(s, mlen); /* mask length */ in_uint16_le(s, dlen); /* data length */ if ((mlen > sizeof(cursor->mask)) || (dlen > sizeof(cursor->data))) { return 1; } in_uint8a(s, cursor->data, dlen); in_uint8a(s, cursor->mask, mlen); self->mod->server_set_cursor(self->mod, cursor->x, cursor->y, cursor->data, cursor->mask); return 0; } /******************************************************************************/ /* Process a cached pointer PDU */ static int APP_CC rdp_rdp_process_cached_pointer_pdu(struct rdp_rdp *self, struct stream *s) { int cache_idx; struct rdp_cursor *cursor; in_uint16_le(s, cache_idx); if (cache_idx > 31) { return 1; } cursor = self->cursors + cache_idx; self->mod->server_set_cursor(self->mod, cursor->x, cursor->y, cursor->data, cursor->mask); return 0; } /******************************************************************************/ /* Process a system pointer PDU */ static int APP_CC rdp_rdp_process_system_pointer_pdu(struct rdp_rdp *self, struct stream *s) { int system_pointer_type; struct rdp_cursor *cursor; in_uint16_le(s, system_pointer_type); switch (system_pointer_type) { case RDP_NULL_POINTER: cursor = (struct rdp_cursor *)g_malloc(sizeof(struct rdp_cursor), 1); g_memset(cursor->mask, 0xff, sizeof(cursor->mask)); self->mod->server_set_cursor(self->mod, cursor->x, cursor->y, cursor->data, cursor->mask); g_free(cursor); break; default: break; } return 0; } /******************************************************************************/ /* Process a pointer PDU */ static int APP_CC rdp_rdp_process_pointer_pdu(struct rdp_rdp *self, struct stream *s) { int message_type; int rv; rv = 0; in_uint16_le(s, message_type); in_uint8s(s, 2); /* pad */ switch (message_type) { case RDP_POINTER_MOVE: in_uint8s(s, 2); /* x */ in_uint8s(s, 2); /* y */ break; case RDP_POINTER_COLOR: rv = rdp_rdp_process_color_pointer_pdu(self, s); break; case RDP_POINTER_CACHED: rv = rdp_rdp_process_cached_pointer_pdu(self, s); break; case RDP_POINTER_SYSTEM: rv = rdp_rdp_process_system_pointer_pdu(self, s); break; default: break; } return rv; } /******************************************************************************/ /* Process bitmap updates */ static void APP_CC rdp_rdp_process_bitmap_updates(struct rdp_rdp *self, struct stream *s) { int num_updates = 0; int left = 0; int top = 0; int right = 0; int bottom = 0; int width = 0; int height = 0; int cx = 0; int cy = 0; int bpp = 0; int Bpp = 0; int compress = 0; int bufsize = 0; int size = 0; int i = 0; int x = 0; int y = 0; char *data = NULL; char *bmpdata0 = NULL; char *bmpdata1 = NULL; in_uint16_le(s, num_updates); for (i = 0; i < num_updates; i++) { in_uint16_le(s, left); in_uint16_le(s, top); in_uint16_le(s, right); in_uint16_le(s, bottom); in_uint16_le(s, width); in_uint16_le(s, height); in_uint16_le(s, bpp); Bpp = (bpp + 7) / 8; in_uint16_le(s, compress); in_uint16_le(s, bufsize); cx = (right - left) + 1; cy = (bottom - top) + 1; bmpdata0 = (char *)g_malloc(width * height * Bpp, 0); if (compress) { if (compress & 0x400) { size = bufsize; } else { in_uint8s(s, 2); /* pad */ in_uint16_le(s, size); in_uint8s(s, 4); /* line_size, final_size */ } in_uint8p(s, data, size); rdp_bitmap_decompress(bmpdata0, width, height, data, size, Bpp); bmpdata1 = rdp_orders_convert_bitmap(bpp, self->mod->xrdp_bpp, bmpdata0, width, height, self->colormap.colors); self->mod->server_paint_rect(self->mod, left, top, cx, cy, bmpdata1, width, height, 0, 0); } else /* not compressed */ { for (y = 0; y < height; y++) { data = bmpdata0 + ((height - y) - 1) * (width * Bpp); if (Bpp == 1) { for (x = 0; x < width; x++) { in_uint8(s, data[x]); } } else if (Bpp == 2) { for (x = 0; x < width; x++) { in_uint16_le(s, ((tui16 *)data)[x]); } } else if (Bpp == 3) { for (x = 0; x < width; x++) { in_uint8(s, data[x * 3 + 0]); in_uint8(s, data[x * 3 + 1]); in_uint8(s, data[x * 3 + 2]); } } } bmpdata1 = rdp_orders_convert_bitmap(bpp, self->mod->xrdp_bpp, bmpdata0, width, height, self->colormap.colors); self->mod->server_paint_rect(self->mod, left, top, cx, cy, bmpdata1, width, height, 0, 0); } if (bmpdata0 != bmpdata1) { g_free(bmpdata1); } g_free(bmpdata0); } } /******************************************************************************/ /* Process a palette update */ static void APP_CC rdp_rdp_process_palette(struct rdp_rdp *self, struct stream *s) { int i; int r; int g; int b; in_uint8s(s, 2); /* pad */ in_uint16_le(s, self->colormap.ncolors); in_uint8s(s, 2); /* pad */ for (i = 0; i < self->colormap.ncolors; i++) { in_uint8(s, r); in_uint8(s, g); in_uint8(s, b); self->colormap.colors[i] = (r << 16) | (g << 8) | b; } //ui_set_colormap(hmap); } /******************************************************************************/ /* Process an update PDU */ static int APP_CC rdp_rdp_process_update_pdu(struct rdp_rdp *self, struct stream *s) { int update_type; int count; in_uint16_le(s, update_type); self->mod->server_begin_update(self->mod); switch (update_type) { case RDP_UPDATE_ORDERS: in_uint8s(s, 2); /* pad */ in_uint16_le(s, count); in_uint8s(s, 2); /* pad */ rdp_orders_process_orders(self->orders, s, count); break; case RDP_UPDATE_BITMAP: rdp_rdp_process_bitmap_updates(self, s); break; case RDP_UPDATE_PALETTE: rdp_rdp_process_palette(self, s); break; case RDP_UPDATE_SYNCHRONIZE: break; default: break; } self->mod->server_end_update(self->mod); return 0; } /******************************************************************************/ void APP_CC rdp_rdp_out_unistr(struct stream *s, char *text) { int i; i = 0; while (text[i] != 0) { out_uint8(s, text[i]); out_uint8(s, 0); i++; } out_uint8(s, 0); out_uint8(s, 0); } /******************************************************************************/ int APP_CC rdp_rdp_send_login_info(struct rdp_rdp *self, int flags) { int len_domain; int len_username; int len_password; int len_program; int len_directory; int sec_flags; struct stream *s; DEBUG(("in rdp_rdp_send_login_info")); make_stream(s); init_stream(s, 8192); len_domain = 2 * g_strlen(self->mod->domain); len_username = 2 * g_strlen(self->mod->username); len_password = 2 * g_strlen(self->mod->password); len_program = 2 * g_strlen(self->mod->program); len_directory = 2 * g_strlen(self->mod->directory); sec_flags = SEC_LOGON_INFO | SEC_ENCRYPT; if (rdp_sec_init(self->sec_layer, s, sec_flags) != 0) { free_stream(s); DEBUG(("out rdp_rdp_send_login_info error 1")); return 1; } out_uint32_le(s, 0); out_uint32_le(s, flags); out_uint16_le(s, len_domain); out_uint16_le(s, len_username); out_uint16_le(s, len_password); out_uint16_le(s, len_program); out_uint16_le(s, len_directory); rdp_rdp_out_unistr(s, self->mod->domain); rdp_rdp_out_unistr(s, self->mod->username); rdp_rdp_out_unistr(s, self->mod->password); rdp_rdp_out_unistr(s, self->mod->program); rdp_rdp_out_unistr(s, self->mod->directory); s_mark_end(s); if (rdp_sec_send(self->sec_layer, s, sec_flags) != 0) { free_stream(s); DEBUG(("out rdp_rdp_send_login_info error 2")); return 1; } free_stream(s); DEBUG(("out rdp_rdp_send_login_info")); return 0; } /******************************************************************************/ int APP_CC rdp_rdp_connect(struct rdp_rdp *self, char *ip, char *port) { int flags; DEBUG(("in rdp_rdp_connect")); flags = RDP_LOGON_NORMAL; if (g_strlen(self->mod->password) > 0) { flags |= RDP_LOGON_AUTO; } if (rdp_sec_connect(self->sec_layer, ip, port) != 0) { DEBUG(("out rdp_rdp_connect error rdp_sec_connect failed")); return 1; } if (rdp_rdp_send_login_info(self, flags) != 0) { DEBUG(("out rdp_rdp_connect error rdp_rdp_send_login_info failed")); return 1; } DEBUG(("out rdp_rdp_connect")); return 0; } /******************************************************************************/ int APP_CC rdp_rdp_send_input(struct rdp_rdp *self, struct stream *s, int time, int message_type, int device_flags, int param1, int param2) { if (rdp_rdp_init_data(self, s) != 0) { return 1; } out_uint16_le(s, 1); /* number of events */ out_uint16_le(s, 0); out_uint32_le(s, time); out_uint16_le(s, message_type); out_uint16_le(s, device_flags); out_uint16_le(s, param1); out_uint16_le(s, param2); s_mark_end(s); if (rdp_rdp_send_data(self, s, RDP_DATA_PDU_INPUT) != 0) { return 1; } return 0; } /******************************************************************************/ int APP_CC rdp_rdp_send_invalidate(struct rdp_rdp *self, struct stream *s, int left, int top, int width, int height) { if (rdp_rdp_init_data(self, s) != 0) { return 1; } out_uint32_le(s, 1); out_uint16_le(s, left); out_uint16_le(s, top); out_uint16_le(s, (left + width) - 1); out_uint16_le(s, (top + height) - 1); s_mark_end(s); if (rdp_rdp_send_data(self, s, 33) != 0) { return 1; } return 0; } /******************************************************************************/ int APP_CC rdp_rdp_recv(struct rdp_rdp *self, struct stream *s, int *type) { int len; int pdu_type; int chan; chan = 0; DEBUG(("in rdp_rdp_recv")); if (s->next_packet >= s->end || s->next_packet == 0) { if (rdp_sec_recv(self->sec_layer, s, &chan) != 0) { DEBUG(("error in rdp_rdp_recv, rdp_sec_recv failed")); return 1; } s->next_packet = s->p; } else { chan = MCS_GLOBAL_CHANNEL; s->p = s->next_packet; } if (chan == MCS_GLOBAL_CHANNEL) { in_uint16_le(s, len); DEBUG(("rdp_rdp_recv got %d len", len)); if (len == 0x8000) { s->next_packet += 8; DEBUG(("out rdp_rdp_recv")); return 0; } in_uint16_le(s, pdu_type); in_uint8s(s, 2); *type = pdu_type & 0xf; s->next_packet += len; } else { /* todo, process channel data */ DEBUG(("got channel data channel %d", chan)); s->next_packet = s->end; } DEBUG(("out rdp_rdp_recv")); return 0; } /******************************************************************************/ static int APP_CC rdp_rdp_process_disconnect_pdu(struct rdp_rdp *self, struct stream *s) { return 0; } /******************************************************************************/ int APP_CC rdp_rdp_process_data_pdu(struct rdp_rdp *self, struct stream *s) { int data_pdu_type; int rv; rv = 0; in_uint8s(s, 6); /* shareid, pad, streamid */ in_uint8s(s, 2); /* len */ in_uint8(s, data_pdu_type); in_uint8s(s, 1); /* ctype */ in_uint8s(s, 2); /* clen */ switch (data_pdu_type) { case RDP_DATA_PDU_UPDATE: rv = rdp_rdp_process_update_pdu(self, s); break; case RDP_DATA_PDU_CONTROL: break; case RDP_DATA_PDU_SYNCHRONISE: break; case RDP_DATA_PDU_POINTER: rv = rdp_rdp_process_pointer_pdu(self, s); break; case RDP_DATA_PDU_PLAY_SOUND: break; case RDP_DATA_PDU_LOGON: break; case RDP_DATA_PDU_DISCONNECT: rv = rdp_rdp_process_disconnect_pdu(self, s); break; default: break; } return rv; } /******************************************************************************/ /* Process a bitmap capability set */ static void APP_CC rdp_rdp_process_general_caps(struct rdp_rdp *self, struct stream *s) { } /******************************************************************************/ /* Process a bitmap capability set */ static void APP_CC rdp_rdp_process_bitmap_caps(struct rdp_rdp *self, struct stream *s) { int bpp = 0; in_uint16_le(s, bpp); in_uint8s(s, 6); in_uint8s(s, 2); /* width */ in_uint8s(s, 2); /* height */ self->mod->rdp_bpp = bpp; /* todo, call reset if needed and use width and height */ } /******************************************************************************/ /* Process server capabilities */ /* returns error */ static int APP_CC rdp_rdp_process_server_caps(struct rdp_rdp *self, struct stream *s, int len) { int n = 0; int ncapsets = 0; int capset_type = 0; int capset_length = 0; char *next = NULL; char *start = NULL; start = s->p; in_uint16_le(s, ncapsets); in_uint8s(s, 2); /* pad */ for (n = 0; n < ncapsets; n++) { if (s->p > start + len) { return 0; } in_uint16_le(s, capset_type); in_uint16_le(s, capset_length); next = (s->p + capset_length) - 4; switch (capset_type) { case RDP_CAPSET_GENERAL: rdp_rdp_process_general_caps(self, s); break; case RDP_CAPSET_BITMAP: rdp_rdp_process_bitmap_caps(self, s); break; default: break; } s->p = next; } return 0; } /******************************************************************************/ /* Send a control PDU */ /* returns error */ static int APP_CC rdp_rdp_send_control(struct rdp_rdp *self, struct stream *s, int action) { if (rdp_rdp_init_data(self, s) != 0) { return 1; } out_uint16_le(s, action); out_uint16_le(s, 0); /* userid */ out_uint32_le(s, 0); /* control id */ s_mark_end(s); if (rdp_rdp_send_data(self, s, RDP_DATA_PDU_CONTROL) != 0) { return 1; } return 0; } /******************************************************************************/ /* Send a synchronisation PDU */ /* returns error */ static int APP_CC rdp_rdp_send_synchronise(struct rdp_rdp *self, struct stream *s) { if (rdp_rdp_init_data(self, s) != 0) { return 1; } out_uint16_le(s, 1); /* type */ out_uint16_le(s, 1002); s_mark_end(s); if (rdp_rdp_send_data(self, s, RDP_DATA_PDU_SYNCHRONISE) != 0) { return 1; } return 0; } /******************************************************************************/ /* Send an (empty) font information PDU */ static int APP_CC rdp_rdp_send_fonts(struct rdp_rdp *self, struct stream *s, int seq) { if (rdp_rdp_init_data(self, s) != 0) { return 1; } out_uint16_le(s, 0); /* number of fonts */ out_uint16_le(s, 0); /* pad? */ out_uint16_le(s, seq); /* unknown */ out_uint16_le(s, 0x32); /* entry size */ s_mark_end(s); if (rdp_rdp_send_data(self, s, RDP_DATA_PDU_FONT2) != 0) { return 1; } return 0; } /******************************************************************************/ /* Respond to a demand active PDU */ int APP_CC rdp_rdp_process_demand_active(struct rdp_rdp *self, struct stream *s) { int type = 0; int len_src_descriptor = 0; int len_combined_caps = 0; in_uint32_le(s, self->share_id); in_uint16_le(s, len_src_descriptor); in_uint16_le(s, len_combined_caps); in_uint8s(s, len_src_descriptor); rdp_rdp_process_server_caps(self, s, len_combined_caps); rdp_rdp_send_confirm_active(self, s); rdp_rdp_send_synchronise(self, s); rdp_rdp_send_control(self, s, RDP_CTL_COOPERATE); rdp_rdp_send_control(self, s, RDP_CTL_REQUEST_CONTROL); rdp_rdp_recv(self, s, &type); /* RDP_PDU_SYNCHRONIZE */ rdp_rdp_recv(self, s, &type); /* RDP_CTL_COOPERATE */ rdp_rdp_recv(self, s, &type); /* RDP_CTL_GRANT_CONTROL */ rdp_rdp_send_input(self, s, 0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0); rdp_rdp_send_fonts(self, s, 1); rdp_rdp_send_fonts(self, s, 2); rdp_rdp_recv(self, s, &type); /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */ rdp_orders_reset_state(self->orders); return 0; } /******************************************************************************/ int APP_CC rdp_rec_check_file(struct rdp_rdp *self) { char file_name[256]; int index = 0; int len = 0; struct stream *s = (struct stream *)NULL; g_memset(file_name, 0, sizeof(char) * 256); if (self->rec_fd == 0) { index = 1; g_sprintf(file_name, "rec%8.8d.rec", index); while (g_file_exist(file_name)) { index++; if (index >= 9999) { return 1; } g_sprintf(file_name, "rec%8.8d.rec", index); } self->rec_fd = g_file_open(file_name); if (self->rec_fd < 0) return 1; make_stream(s); init_stream(s, 8192); out_uint8a(s, "XRDPREC1", 8); out_uint8s(s, 8); s_mark_end(s); len = s->end - s->data; g_file_write(self->rec_fd, s->data, len); free_stream(s); } return 0; } /******************************************************************************/ int APP_CC rdp_rec_write_item(struct rdp_rdp *self, struct stream *s) { int len = 0; int time = 0; if (self->rec_fd == 0) { return 1; } time = g_time1(); out_uint32_le(s, time); s_mark_end(s); len = s->end - s->data; s_pop_layer(s, iso_hdr); out_uint32_le(s, len); g_file_write(self->rec_fd, s->data, len); return 0; }