You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
xrdp-proprietary/rdp/rdp_orders.c

1529 lines
43 KiB

/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2005-2008
librdp orders
*/
#include "rdp.h"
/*****************************************************************************/
struct rdp_orders* APP_CC
rdp_orders_create(struct rdp_rdp* owner)
{
struct rdp_orders* self;
self = (struct rdp_orders*)g_malloc(sizeof(struct rdp_orders), 1);
self->rdp_layer = owner;
return self;
}
/*****************************************************************************/
void APP_CC
rdp_orders_delete(struct rdp_orders* self)
{
int i;
int j;
if (self == 0)
{
return;
}
/* free the colormap cache */
for (i = 0; i < 6; i++)
{
g_free(self->cache_colormap[i]);
}
/* free the bitmap cache */
for (i = 0; i < 3; i++)
{
for (j = 0; j < 600; j++)
{
if (self->cache_bitmap[i][j] != 0)
{
g_free(self->cache_bitmap[i][j]->data);
}
g_free(self->cache_bitmap[i][j]);
}
}
g_free(self);
}
/*****************************************************************************/
void APP_CC
rdp_orders_reset_state(struct rdp_orders* self)
{
g_memset(&self->state, 0, sizeof(self->state));
}
/*****************************************************************************/
/* Read field indicating which parameters are present */
static void APP_CC
rdp_orders_in_present(struct stream* s, int* present,
int flags, int size)
{
int bits;
int i;
if (flags & RDP_ORDER_SMALL)
{
size--;
}
if (flags & RDP_ORDER_TINY)
{
if (size < 2)
{
size = 0;
}
else
{
size -= 2;
}
}
*present = 0;
for (i = 0; i < size; i++)
{
in_uint8(s, bits);
*present |= bits << (i * 8);
}
}
/*****************************************************************************/
/* Read a co-ordinate (16-bit, or 8-bit delta) */
static void APP_CC
rdp_orders_in_coord(struct stream* s, int* coord, int delta)
{
int change;
if (delta)
{
in_sint8(s, change);
*coord += change;
}
else
{
in_sint16_le(s, *coord);
}
}
/*****************************************************************************/
/* Parse bounds information */
static void APP_CC
rdp_orders_parse_bounds(struct rdp_orders* self, struct stream* s)
{
int present;
in_uint8(s, present);
if (present & 1)
{
rdp_orders_in_coord(s, &self->state.clip_left, 0);
}
else if (present & 16)
{
rdp_orders_in_coord(s, &self->state.clip_left, 1);
}
if (present & 2)
{
rdp_orders_in_coord(s, &self->state.clip_top, 0);
}
else if (present & 32)
{
rdp_orders_in_coord(s, &self->state.clip_top, 1);
}
if (present & 4)
{
rdp_orders_in_coord(s, &self->state.clip_right, 0);
}
else if (present & 64)
{
rdp_orders_in_coord(s, &self->state.clip_right, 1);
}
if (present & 8)
{
rdp_orders_in_coord(s, &self->state.clip_bottom, 0);
}
else if (present & 128)
{
rdp_orders_in_coord(s, &self->state.clip_bottom, 1);
}
}
/*****************************************************************************/
/* Process a colormap cache order */
static void APP_CC
rdp_orders_process_colcache(struct rdp_orders* self, struct stream* s,
int flags)
{
struct rdp_colormap* colormap;
struct stream* rec_s;
int cache_id;
int i;
colormap = (struct rdp_colormap*)g_malloc(sizeof(struct rdp_colormap), 1);
in_uint8(s, cache_id);
in_uint16_le(s, colormap->ncolors);
for (i = 0; i < colormap->ncolors; i++)
{
in_uint32_le(s, colormap->colors[i]);
}
g_free(self->cache_colormap[cache_id]);
self->cache_colormap[cache_id] = colormap;
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 4096);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 10);
out_uint8(rec_s, cache_id);
for (i = 0; i < 256; i++)
{
out_uint32_le(rec_s, colormap->colors[i]);
}
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a raw bitmap cache order */
static void APP_CC
rdp_orders_process_raw_bmpcache(struct rdp_orders* self, struct stream* s,
int flags)
{
int cache_idx;
int bufsize;
int cache_id;
int width;
int height;
int bpp;
int Bpp;
int x;
int y;
char* inverted;
char* dst;
struct rdp_bitmap* bitmap;
struct stream* rec_s;
in_uint8(s, cache_id);
in_uint8s(s, 1);
in_uint8(s, width);
in_uint8(s, height);
in_uint8(s, bpp);
Bpp = (bpp + 7) / 8;
in_uint16_le(s, bufsize);
in_uint16_le(s, cache_idx);
inverted = (char*)g_malloc(width * height * Bpp, 0);
for (y = 0; y < height; y++)
{
dst = inverted + (((height - y) - 1) * (width * Bpp));
if (Bpp == 1)
{
for (x = 0; x < width; x++)
{
in_uint8(s, dst[x]);
}
}
else if (Bpp == 2)
{
for (x = 0; x < width; x++)
{
in_uint16_le(s, ((tui16*)dst)[x]);
}
}
else if (Bpp == 3)
{
for (x = 0; x < width; x++)
{
in_uint8(s, dst[x * 3 + 0]);
in_uint8(s, dst[x * 3 + 1]);
in_uint8(s, dst[x * 3 + 2]);
}
}
}
bitmap = (struct rdp_bitmap*)g_malloc(sizeof(struct rdp_bitmap), 0);
bitmap->width = width;
bitmap->height = height;
bitmap->bpp = bpp;
bitmap->data = inverted;
if (self->cache_bitmap[cache_id][cache_idx] != 0)
{
g_free(self->cache_bitmap[cache_id][cache_idx]->data);
}
g_free(self->cache_bitmap[cache_id][cache_idx]);
self->cache_bitmap[cache_id][cache_idx] = bitmap;
if (self->rdp_layer->rec_mode)
{
y = width * height * Bpp;
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, y + 256);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 8);
out_uint8(rec_s, cache_id);
out_uint16_le(rec_s, cache_idx);
out_uint16_le(rec_s, width);
out_uint16_le(rec_s, height);
out_uint16_le(rec_s, y);
out_uint8a(rec_s, inverted, y);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a bitmap cache order */
static void APP_CC
rdp_orders_process_bmpcache(struct rdp_orders* self, struct stream* s,
int flags)
{
char* data;
char* bmpdata;
int cache_idx;
int size;
int cache_id;
int width;
int height;
int bpp;
int Bpp;
int bufsize;
int pad1;
int pad2;
int row_size;
int final_size;
struct rdp_bitmap* bitmap;
struct stream* rec_s;
in_uint8(s, cache_id);
in_uint8(s, pad1);
in_uint8(s, width);
in_uint8(s, height);
in_uint8(s, bpp);
Bpp = (bpp + 7) / 8;
in_uint16_le(s, bufsize);
in_uint16_le(s, cache_idx);
if (flags & 1024)
{
size = bufsize;
}
else
{
in_uint16_le(s, pad2);
in_uint16_le(s, size);
in_uint16_le(s, row_size);
in_uint16_le(s, final_size);
}
in_uint8p(s, data, size);
bmpdata = (char*)g_malloc(width * height * Bpp, 0);
if (rdp_bitmap_decompress(bmpdata, width, height, data, size, Bpp))
{
}
else
{
/* error */
}
bitmap = (struct rdp_bitmap*)g_malloc(sizeof(struct rdp_bitmap), 0);
bitmap->width = width;
bitmap->height = height;
bitmap->bpp = bpp;
bitmap->data = bmpdata;
if (self->cache_bitmap[cache_id][cache_idx] != 0)
{
g_free(self->cache_bitmap[cache_id][cache_idx]->data);
}
g_free(self->cache_bitmap[cache_id][cache_idx]);
self->cache_bitmap[cache_id][cache_idx] = bitmap;
if (self->rdp_layer->rec_mode)
{
size = width * height * Bpp;
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, size + 256);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 8);
out_uint8(rec_s, cache_id);
out_uint16_le(rec_s, cache_idx);
out_uint16_le(rec_s, width);
out_uint16_le(rec_s, height);
out_uint16_le(rec_s, size);
out_uint8a(rec_s, bmpdata, size);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a font cache order */
static void APP_CC
rdp_orders_process_fontcache(struct rdp_orders* self, struct stream* s,
int flags)
{
struct stream* rec_s;
int font;
int nglyphs;
int character;
int offset;
int baseline;
int width;
int height;
int i;
int datasize;
char* data;
in_uint8(s, font);
in_uint8(s, nglyphs);
for (i = 0; i < nglyphs; i++)
{
in_uint16_le(s, character);
in_uint16_le(s, offset);
in_uint16_le(s, baseline);
in_uint16_le(s, width);
in_uint16_le(s, height);
datasize = (height * ((width + 7) / 8) + 3) & ~3;
in_uint8p(s, data, datasize);
self->rdp_layer->mod->server_add_char(self->rdp_layer->mod, font,
character, offset, baseline,
width, height, data);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, datasize + 256);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 9);
out_uint8(rec_s, font);
out_uint16_le(rec_s, character);
out_uint16_le(rec_s, offset);
out_uint16_le(rec_s, baseline);
out_uint16_le(rec_s, width);
out_uint16_le(rec_s, height);
out_uint16_le(rec_s, datasize);
out_uint8a(rec_s, data, datasize);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
}
/*****************************************************************************/
/* Process a secondary order */
static int APP_CC
rdp_orders_process_secondary_order(struct rdp_orders* self, struct stream* s)
{
short length;
int flags;
int type;
char* next_order;
in_uint16_le(s, length);
in_uint16_le(s, flags);
in_uint8(s, type);
next_order = s->p + length + 7;
switch (type)
{
case RDP_ORDER_COLCACHE:
rdp_orders_process_colcache(self, s, flags);
break;
case RDP_ORDER_RAW_BMPCACHE:
rdp_orders_process_raw_bmpcache(self, s, flags);
break;
case RDP_ORDER_BMPCACHE:
rdp_orders_process_bmpcache(self, s, flags);
break;
case RDP_ORDER_FONTCACHE:
rdp_orders_process_fontcache(self, s, flags);
break;
default:
/* error, unknown order */
break;
}
s->p = next_order;
return 0;
}
/*****************************************************************************/
/* Read a color entry */
static void APP_CC
rdp_orders_in_color(struct stream* s, int* color)
{
int i;
in_uint8(s, i);
*color = i;
in_uint8(s, i);
*color |= i << 8;
in_uint8(s, i);
*color |= i << 16;
}
/*****************************************************************************/
/* Parse a brush */
static void APP_CC
rdp_orders_parse_brush(struct stream* s, struct rdp_brush* brush, int present)
{
if (present & 1)
{
in_uint8(s, brush->xorigin);
}
if (present & 2)
{
in_uint8(s, brush->yorigin);
}
if (present & 4)
{
in_uint8(s, brush->style);
}
if (present & 8)
{
in_uint8(s, brush->pattern[0]);
}
if (present & 16)
{
in_uint8a(s, brush->pattern + 1, 7);
}
}
/*****************************************************************************/
/* Parse a pen */
static void APP_CC
rdp_orders_parse_pen(struct stream* s, struct rdp_pen* pen, int present)
{
if (present & 1)
{
in_uint8(s, pen->style);
}
if (present & 2)
{
in_uint8(s, pen->width);
}
if (present & 4)
{
rdp_orders_in_color(s, &pen->color);
}
}
/*****************************************************************************/
/* Process a text order */
static void APP_CC
rdp_orders_process_text2(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
int fgcolor;
int bgcolor;
struct stream* rec_s;
if (present & 0x000001)
{
in_uint8(s, self->state.text_font);
}
if (present & 0x000002)
{
in_uint8(s, self->state.text_flags);
}
if (present & 0x000004)
{
in_uint8(s, self->state.text_opcode);
}
if (present & 0x000008)
{
in_uint8(s, self->state.text_mixmode);
}
if (present & 0x000010)
{
rdp_orders_in_color(s, &self->state.text_fgcolor);
}
if (present & 0x000020)
{
rdp_orders_in_color(s, &self->state.text_bgcolor);
}
if (present & 0x000040)
{
in_sint16_le(s, self->state.text_clipleft);
}
if (present & 0x000080)
{
in_sint16_le(s, self->state.text_cliptop);
}
if (present & 0x000100)
{
in_sint16_le(s, self->state.text_clipright);
}
if (present & 0x000200)
{
in_sint16_le(s, self->state.text_clipbottom);
}
if (present & 0x000400)
{
in_sint16_le(s, self->state.text_boxleft);
}
if (present & 0x000800)
{
in_sint16_le(s, self->state.text_boxtop);
}
if (present & 0x001000)
{
in_sint16_le(s, self->state.text_boxright);
}
if (present & 0x002000)
{
in_sint16_le(s, self->state.text_boxbottom);
}
rdp_orders_parse_brush(s, &self->state.text_brush, present >> 14);
if (present & 0x080000)
{
in_sint16_le(s, self->state.text_x);
}
if (present & 0x100000)
{
in_sint16_le(s, self->state.text_y);
}
if (present & 0x200000)
{
in_uint8(s, self->state.text_length);
in_uint8a(s, self->state.text_text, self->state.text_length);
}
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod,
self->state.text_opcode);
fgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.text_fgcolor,
self->rdp_layer->colormap.colors);
self->rdp_layer->mod->server_set_fgcolor(self->rdp_layer->mod, fgcolor);
bgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.text_bgcolor,
self->rdp_layer->colormap.colors);
self->rdp_layer->mod->server_set_bgcolor(self->rdp_layer->mod, bgcolor);
self->rdp_layer->mod->server_draw_text(self->rdp_layer->mod,
self->state.text_font,
self->state.text_flags,
self->state.text_mixmode,
self->state.text_clipleft,
self->state.text_cliptop,
self->state.text_clipright,
self->state.text_clipbottom,
self->state.text_boxleft,
self->state.text_boxtop,
self->state.text_boxright,
self->state.text_boxbottom,
self->state.text_x,
self->state.text_y,
self->state.text_text,
self->state.text_length);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod, 0xcc);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 7);
out_uint8(rec_s, self->state.text_font);
out_uint8(rec_s, self->state.text_flags);
out_uint8(rec_s, self->state.text_opcode);
out_uint8(rec_s, self->state.text_mixmode);
out_uint32_le(rec_s, self->state.text_fgcolor);
out_uint32_le(rec_s, self->state.text_bgcolor);
out_uint16_le(rec_s, self->state.text_clipleft);
out_uint16_le(rec_s, self->state.text_cliptop);
out_uint16_le(rec_s, self->state.text_clipright);
out_uint16_le(rec_s, self->state.text_clipbottom);
out_uint16_le(rec_s, self->state.text_boxleft);
out_uint16_le(rec_s, self->state.text_boxtop);
out_uint16_le(rec_s, self->state.text_boxright);
out_uint16_le(rec_s, self->state.text_boxbottom);
out_uint16_le(rec_s, self->state.text_x);
out_uint16_le(rec_s, self->state.text_y);
out_uint16_le(rec_s, self->state.text_length);
out_uint8a(rec_s, self->state.text_text, self->state.text_length);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a destination blt order */
static void APP_CC
rdp_orders_process_destblt(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
struct stream* rec_s;
if (present & 0x01)
{
rdp_orders_in_coord(s, &self->state.dest_x, delta);
}
if (present & 0x02)
{
rdp_orders_in_coord(s, &self->state.dest_y, delta);
}
if (present & 0x04)
{
rdp_orders_in_coord(s, &self->state.dest_cx, delta);
}
if (present & 0x08)
{
rdp_orders_in_coord(s, &self->state.dest_cy, delta);
}
if (present & 0x10)
{
in_uint8(s, self->state.dest_opcode);
}
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod,
self->state.dest_opcode);
self->rdp_layer->mod->server_fill_rect(self->rdp_layer->mod,
self->state.dest_x,
self->state.dest_y,
self->state.dest_cx,
self->state.dest_cy);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod, 0xcc);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 6);
out_uint16_le(rec_s, self->state.dest_x);
out_uint16_le(rec_s, self->state.dest_y);
out_uint16_le(rec_s, self->state.dest_cx);
out_uint16_le(rec_s, self->state.dest_cy);
out_uint8(rec_s, self->state.dest_opcode);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a pattern blt order */
static void APP_CC
rdp_orders_process_patblt(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
int fgcolor;
int bgcolor;
struct stream* rec_s;
if (present & 0x0001)
{
rdp_orders_in_coord(s, &self->state.pat_x, delta);
}
if (present & 0x0002)
{
rdp_orders_in_coord(s, &self->state.pat_y, delta);
}
if (present & 0x0004)
{
rdp_orders_in_coord(s, &self->state.pat_cx, delta);
}
if (present & 0x0008)
{
rdp_orders_in_coord(s, &self->state.pat_cy, delta);
}
if (present & 0x0010)
{
in_uint8(s, self->state.pat_opcode);
}
if (present & 0x0020)
{
rdp_orders_in_color(s, &self->state.pat_bgcolor);
}
if (present & 0x0040)
{
rdp_orders_in_color(s, &self->state.pat_fgcolor);
}
rdp_orders_parse_brush(s, &self->state.pat_brush, present >> 7);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod,
self->state.pat_opcode);
self->rdp_layer->mod->server_set_mixmode(self->rdp_layer->mod, 1);
fgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.pat_fgcolor,
self->rdp_layer->colormap.colors);
self->rdp_layer->mod->server_set_fgcolor(self->rdp_layer->mod, fgcolor);
bgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.pat_bgcolor,
self->rdp_layer->colormap.colors);
self->rdp_layer->mod->server_set_bgcolor(self->rdp_layer->mod, bgcolor);
self->rdp_layer->mod->server_set_brush(self->rdp_layer->mod,
self->state.pat_brush.xorigin,
self->state.pat_brush.yorigin,
self->state.pat_brush.style,
self->state.pat_brush.pattern);
self->rdp_layer->mod->server_fill_rect(self->rdp_layer->mod,
self->state.pat_x,
self->state.pat_y,
self->state.pat_cx,
self->state.pat_cy);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod, 0xcc);
self->rdp_layer->mod->server_set_mixmode(self->rdp_layer->mod, 0);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 5);
out_uint16_le(rec_s, self->state.pat_x);
out_uint16_le(rec_s, self->state.pat_y);
out_uint16_le(rec_s, self->state.pat_cx);
out_uint16_le(rec_s, self->state.pat_cy);
out_uint8(rec_s, self->state.pat_opcode);
out_uint32_le(rec_s, self->state.pat_fgcolor);
out_uint32_le(rec_s, self->state.pat_bgcolor);
out_uint8(rec_s, self->state.pat_brush.xorigin);
out_uint8(rec_s, self->state.pat_brush.yorigin);
out_uint8(rec_s, self->state.pat_brush.style);
out_uint8a(rec_s, self->state.pat_brush.pattern, 8);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a screen blt order */
static void APP_CC
rdp_orders_process_screenblt(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
struct stream* rec_s;
if (present & 0x0001)
{
rdp_orders_in_coord(s, &self->state.screenblt_x, delta);
}
if (present & 0x0002)
{
rdp_orders_in_coord(s, &self->state.screenblt_y, delta);
}
if (present & 0x0004)
{
rdp_orders_in_coord(s, &self->state.screenblt_cx, delta);
}
if (present & 0x0008)
{
rdp_orders_in_coord(s, &self->state.screenblt_cy, delta);
}
if (present & 0x0010)
{
in_uint8(s, self->state.screenblt_opcode);
}
if (present & 0x0020)
{
rdp_orders_in_coord(s, &self->state.screenblt_srcx, delta);
}
if (present & 0x0040)
{
rdp_orders_in_coord(s, &self->state.screenblt_srcy, delta);
}
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod,
self->state.screenblt_opcode);
self->rdp_layer->mod->server_screen_blt(self->rdp_layer->mod,
self->state.screenblt_x,
self->state.screenblt_y,
self->state.screenblt_cx,
self->state.screenblt_cy,
self->state.screenblt_srcx,
self->state.screenblt_srcy);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod, 0xcc);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 4);
out_uint16_le(rec_s, self->state.screenblt_x);
out_uint16_le(rec_s, self->state.screenblt_y);
out_uint16_le(rec_s, self->state.screenblt_cx);
out_uint16_le(rec_s, self->state.screenblt_cy);
out_uint16_le(rec_s, self->state.screenblt_srcx);
out_uint16_le(rec_s, self->state.screenblt_srcy);
out_uint8(rec_s, self->state.screenblt_opcode);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a line order */
static void APP_CC
rdp_orders_process_line(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
int bgcolor;
int fgcolor;
struct stream* rec_s;
if (present & 0x0001)
{
in_uint16_le(s, self->state.line_mixmode);
}
if (present & 0x0002)
{
rdp_orders_in_coord(s, &self->state.line_startx, delta);
}
if (present & 0x0004)
{
rdp_orders_in_coord(s, &self->state.line_starty, delta);
}
if (present & 0x0008)
{
rdp_orders_in_coord(s, &self->state.line_endx, delta);
}
if (present & 0x0010)
{
rdp_orders_in_coord(s, &self->state.line_endy, delta);
}
if (present & 0x0020)
{
rdp_orders_in_color(s, &self->state.line_bgcolor);
}
if (present & 0x0040)
{
in_uint8(s, self->state.line_opcode);
}
rdp_orders_parse_pen(s, &self->state.line_pen, present >> 7);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod,
self->state.line_opcode);
bgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.line_bgcolor,
self->rdp_layer->colormap.colors);
fgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.line_pen.color,
self->rdp_layer->colormap.colors);
self->rdp_layer->mod->server_set_fgcolor(self->rdp_layer->mod, fgcolor);
self->rdp_layer->mod->server_set_bgcolor(self->rdp_layer->mod, bgcolor);
self->rdp_layer->mod->server_set_pen(self->rdp_layer->mod,
self->state.line_pen.style,
self->state.line_pen.width);
self->rdp_layer->mod->server_draw_line(self->rdp_layer->mod,
self->state.line_startx,
self->state.line_starty,
self->state.line_endx,
self->state.line_endy);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod, 0xcc);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 3);
out_uint16_le(rec_s, self->state.line_mixmode);
out_uint16_le(rec_s, self->state.line_startx);
out_uint16_le(rec_s, self->state.line_starty);
out_uint16_le(rec_s, self->state.line_endx);
out_uint16_le(rec_s, self->state.line_endy);
out_uint32_le(rec_s, self->state.line_bgcolor);
out_uint8(rec_s, self->state.line_opcode);
out_uint8(rec_s, self->state.line_pen.style);
out_uint8(rec_s, self->state.line_pen.width);
out_uint32_le(rec_s, self->state.line_pen.color);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process an opaque rectangle order */
static void APP_CC
rdp_orders_process_rect(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
int i;
int fgcolor;
struct stream* rec_s;
if (present & 0x01)
{
rdp_orders_in_coord(s, &self->state.rect_x, delta);
}
if (present & 0x02)
{
rdp_orders_in_coord(s, &self->state.rect_y, delta);
}
if (present & 0x04)
{
rdp_orders_in_coord(s, &self->state.rect_cx, delta);
}
if (present & 0x08)
{
rdp_orders_in_coord(s, &self->state.rect_cy, delta);
}
if (present & 0x10)
{
in_uint8(s, i);
self->state.rect_color = (self->state.rect_color & 0xffffff00) | i;
}
if (present & 0x20)
{
in_uint8(s, i);
self->state.rect_color = (self->state.rect_color & 0xffff00ff) | (i << 8);
}
if (present & 0x40)
{
in_uint8(s, i);
self->state.rect_color = (self->state.rect_color & 0xff00ffff) | (i << 16);
}
fgcolor = rdp_orders_convert_color(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
self->state.rect_color,
self->rdp_layer->colormap.colors);
self->rdp_layer->mod->server_set_fgcolor(self->rdp_layer->mod, fgcolor);
self->rdp_layer->mod->server_fill_rect(self->rdp_layer->mod,
self->state.rect_x,
self->state.rect_y,
self->state.rect_cx,
self->state.rect_cy);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 1);
out_uint16_le(rec_s, self->state.rect_x);
out_uint16_le(rec_s, self->state.rect_y);
out_uint16_le(rec_s, self->state.rect_cx);
out_uint16_le(rec_s, self->state.rect_cy);
out_uint32_le(rec_s, self->state.rect_color);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
}
/*****************************************************************************/
/* Process a desktop save order */
static void APP_CC
rdp_orders_process_desksave(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
int width;
int height;
if (present & 0x01)
{
in_uint32_le(s, self->state.desksave_offset);
}
if (present & 0x02)
{
rdp_orders_in_coord(s, &self->state.desksave_left, delta);
}
if (present & 0x04)
{
rdp_orders_in_coord(s, &self->state.desksave_top, delta);
}
if (present & 0x08)
{
rdp_orders_in_coord(s, &self->state.desksave_right, delta);
}
if (present & 0x10)
{
rdp_orders_in_coord(s, &self->state.desksave_bottom, delta);
}
if (present & 0x20)
{
in_uint8(s, self->state.desksave_action);
}
width = (self->state.desksave_right - self->state.desksave_left) + 1;
height = (self->state.desksave_bottom - self->state.desksave_top) + 1;
if (self->state.desksave_action == 0)
{
// ui_desktop_save(os->offset, os->left, os->top, width, height);
}
else
{
// ui_desktop_restore(os->offset, os->left, os->top, width, height);
}
}
/*****************************************************************************/
/* Process a memory blt order */
static void APP_CC
rdp_orders_process_memblt(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
struct rdp_bitmap* bitmap;
struct stream* rec_s;
char* bmpdata;
if (present & 0x0001)
{
in_uint8(s, self->state.memblt_cache_id);
in_uint8(s, self->state.memblt_color_table);
}
if (present & 0x0002)
{
rdp_orders_in_coord(s, &self->state.memblt_x, delta);
}
if (present & 0x0004)
{
rdp_orders_in_coord(s, &self->state.memblt_y, delta);
}
if (present & 0x0008)
{
rdp_orders_in_coord(s, &self->state.memblt_cx, delta);
}
if (present & 0x0010)
{
rdp_orders_in_coord(s, &self->state.memblt_cy, delta);
}
if (present & 0x0020)
{
in_uint8(s, self->state.memblt_opcode);
}
if (present & 0x0040)
{
rdp_orders_in_coord(s, &self->state.memblt_srcx, delta);
}
if (present & 0x0080)
{
rdp_orders_in_coord(s, &self->state.memblt_srcy, delta);
}
if (present & 0x0100)
{
in_uint16_le(s, self->state.memblt_cache_idx);
}
bitmap = self->cache_bitmap[self->state.memblt_cache_id]
[self->state.memblt_cache_idx];
if (bitmap != 0)
{
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod,
self->state.memblt_opcode);
bmpdata = rdp_orders_convert_bitmap(self->rdp_layer->mod->rdp_bpp,
self->rdp_layer->mod->xrdp_bpp,
bitmap->data, bitmap->width,
bitmap->height,
self->cache_colormap
[self->state.memblt_color_table]->colors);
self->rdp_layer->mod->server_paint_rect(self->rdp_layer->mod,
self->state.memblt_x,
self->state.memblt_y,
self->state.memblt_cx,
self->state.memblt_cy,
bmpdata,
bitmap->width,
bitmap->height,
self->state.memblt_srcx,
self->state.memblt_srcy);
self->rdp_layer->mod->server_set_opcode(self->rdp_layer->mod, 0xcc);
if (self->rdp_layer->rec_mode)
{
rdp_rec_check_file(self->rdp_layer);
make_stream(rec_s);
init_stream(rec_s, 512);
s_push_layer(rec_s, iso_hdr, 4);
out_uint8(rec_s, 2);
out_uint8(rec_s, self->state.memblt_opcode);
out_uint16_le(rec_s, self->state.memblt_x);
out_uint16_le(rec_s, self->state.memblt_y);
out_uint16_le(rec_s, self->state.memblt_cx);
out_uint16_le(rec_s, self->state.memblt_cy);
out_uint16_le(rec_s, self->state.memblt_cache_id);
out_uint16_le(rec_s, self->state.memblt_cache_idx);
out_uint16_le(rec_s, self->state.memblt_srcx);
out_uint16_le(rec_s, self->state.memblt_srcy);
rdp_rec_write_item(self->rdp_layer, rec_s);
free_stream(rec_s);
}
if (bmpdata != bitmap->data)
{
g_free(bmpdata);
}
}
}
/*****************************************************************************/
/* Process a 3-way blt order */
static void APP_CC
rdp_orders_process_triblt(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
/* not used */
}
/*****************************************************************************/
/* Process a polyline order */
static void APP_CC
rdp_orders_process_polyline(struct rdp_orders* self, struct stream* s,
int present, int delta)
{
if (present & 0x01)
{
rdp_orders_in_coord(s, &self->state.polyline_x, delta);
}
if (present & 0x02)
{
rdp_orders_in_coord(s, &self->state.polyline_y, delta);
}
if (present & 0x04)
{
in_uint8(s, self->state.polyline_opcode);
}
if (present & 0x10)
{
rdp_orders_in_color(s, &self->state.polyline_fgcolor);
}
if (present & 0x20)
{
in_uint8(s, self->state.polyline_lines);
}
if (present & 0x40)
{
in_uint8(s, self->state.polyline_datasize);
in_uint8a(s, self->state.polyline_data, self->state.polyline_datasize);
}
/* todo */
}
/*****************************************************************************/
int APP_CC
rdp_orders_process_orders(struct rdp_orders* self, struct stream* s,
int num_orders)
{
int processed;
int order_flags;
int size;
int present;
int delta;
processed = 0;
while (processed < num_orders)
{
in_uint8(s, order_flags);
if (!(order_flags & RDP_ORDER_STANDARD))
{
/* error, this should always be set */
break;
}
if (order_flags & RDP_ORDER_SECONDARY)
{
rdp_orders_process_secondary_order(self, s);
}
else
{
if (order_flags & RDP_ORDER_CHANGE)
{
in_uint8(s, self->state.order_type);
}
switch (self->state.order_type)
{
case RDP_ORDER_TRIBLT:
case RDP_ORDER_TEXT2:
size = 3;
break;
case RDP_ORDER_PATBLT:
case RDP_ORDER_MEMBLT:
case RDP_ORDER_LINE:
size = 2;
break;
default:
size = 1;
break;
}
rdp_orders_in_present(s, &present, order_flags, size);
if (order_flags & RDP_ORDER_BOUNDS)
{
if (!(order_flags & RDP_ORDER_LASTBOUNDS))
{
rdp_orders_parse_bounds(self, s);
}
self->rdp_layer->mod->server_set_clip(self->rdp_layer->mod,
self->state.clip_left,
self->state.clip_top,
(self->state.clip_right - self->state.clip_left) + 1,
(self->state.clip_bottom - self->state.clip_top) + 1);
}
delta = order_flags & RDP_ORDER_DELTA;
switch (self->state.order_type)
{
case RDP_ORDER_TEXT2:
rdp_orders_process_text2(self, s, present, delta);
break;
case RDP_ORDER_DESTBLT:
rdp_orders_process_destblt(self, s, present, delta);
break;
case RDP_ORDER_PATBLT:
rdp_orders_process_patblt(self, s, present, delta);
break;
case RDP_ORDER_SCREENBLT:
rdp_orders_process_screenblt(self, s, present, delta);
break;
case RDP_ORDER_LINE:
rdp_orders_process_line(self, s, present, delta);
break;
case RDP_ORDER_RECT:
rdp_orders_process_rect(self, s, present, delta);
break;
case RDP_ORDER_DESKSAVE:
rdp_orders_process_desksave(self, s, present, delta);
break;
case RDP_ORDER_MEMBLT:
rdp_orders_process_memblt(self, s, present, delta);
break;
case RDP_ORDER_TRIBLT:
rdp_orders_process_triblt(self, s, present, delta);
break;
case RDP_ORDER_POLYLINE:
rdp_orders_process_polyline(self, s, present, delta);
break;
default:
/* error unknown order */
break;
}
if (order_flags & RDP_ORDER_BOUNDS)
{
self->rdp_layer->mod->server_reset_clip(self->rdp_layer->mod);
}
}
processed++;
}
return 0;
}
/*****************************************************************************/
/* returns pointer, it might return bmpdata if the data dosen't need to
be converted, else it mallocs it. The calling function must free
it if needed */
char* APP_CC
rdp_orders_convert_bitmap(int in_bpp, int out_bpp, char* bmpdata,
int width, int height, int* palette)
{
char* out;
char* src;
char* dst;
int i;
int j;
int red;
int green;
int blue;
int pixel;
if ((in_bpp == 8) && (out_bpp == 8))
{
out = (char*)g_malloc(width * height, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
pixel = *((tui8*)src);
pixel = palette[pixel];
SPLITCOLOR32(red, green, blue, pixel);
pixel = COLOR8(red, green, blue);
*dst = pixel;
src++;
dst++;
}
}
return out;
}
if ((in_bpp == 8) && (out_bpp == 16))
{
out = (char*)g_malloc(width * height * 2, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
pixel = *((tui8*)src);
pixel = palette[pixel];
SPLITCOLOR32(red, green, blue, pixel);
pixel = COLOR16(red, green, blue);
*((tui16*)dst) = pixel;
src++;
dst += 2;
}
}
return out;
}
if ((in_bpp == 8) && (out_bpp == 24))
{
out = (char*)g_malloc(width * height * 4, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
pixel = *((tui8*)src);
pixel = palette[pixel];
SPLITCOLOR32(red, green, blue, pixel);
pixel = COLOR24RGB(red, green, blue);
*((tui32*)dst) = pixel;
src++;;
dst += 4;
}
}
return out;
}
if ((in_bpp == 15) && (out_bpp == 16))
{
out = (char*)g_malloc(width * height * 2, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
pixel = *((tui16*)src);
SPLITCOLOR15(red, green, blue, pixel);
pixel = COLOR16(red, green, blue);
*((tui16*)dst) = pixel;
src += 2;
dst += 2;
}
}
return out;
}
if ((in_bpp == 15) && (out_bpp == 24))
{
out = (char*)g_malloc(width * height * 4, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
pixel = *((tui16*)src);
SPLITCOLOR15(red, green, blue, pixel);
pixel = COLOR24RGB(red, green, blue);
*((tui32*)dst) = pixel;
src += 2;
dst += 4;
}
}
return out;
}
if ((in_bpp == 16) && (out_bpp == 16))
{
return bmpdata;
}
if ((in_bpp == 16) && (out_bpp == 24))
{
out = (char*)g_malloc(width * height * 4, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
pixel = *((tui16*)src);
SPLITCOLOR16(red, green, blue, pixel);
pixel = COLOR24RGB(red, green, blue);
*((tui32*)dst) = pixel;
src += 2;
dst += 4;
}
}
return out;
}
if ((in_bpp == 24) && (out_bpp == 24))
{
out = (char*)g_malloc(width * height * 4, 0);
src = bmpdata;
dst = out;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
blue = *((tui8*)src);
src++;
green = *((tui8*)src);
src++;
red = *((tui8*)src);
src++;
pixel = COLOR24RGB(red, green, blue);
*((tui32*)dst) = pixel;
dst += 4;
}
}
return out;
}
return 0;
}
/*****************************************************************************/
/* returns color or 0 */
int APP_CC
rdp_orders_convert_color(int in_bpp, int out_bpp, int in_color, int* palette)
{
int pixel;
int red;
int green;
int blue;
if ((in_bpp == 8) && (out_bpp == 8))
{
pixel = palette[in_color];
SPLITCOLOR32(red, green, blue, pixel);
pixel = COLOR8(red, green, blue);
return pixel;
}
if ((in_bpp == 8) && (out_bpp == 16))
{
pixel = palette[in_color];
SPLITCOLOR32(red, green, blue, pixel);
pixel = COLOR16(red, green, blue);
return pixel;
}
if ((in_bpp == 8) && (out_bpp == 24))
{
pixel = palette[in_color];
SPLITCOLOR32(red, green, blue, pixel);
pixel = COLOR24BGR(red, green, blue);
return pixel;
}
if ((in_bpp == 15) && (out_bpp == 16))
{
pixel = in_color;
SPLITCOLOR15(red, green, blue, pixel);
pixel = COLOR16(red, green, blue);
return pixel;
}
if ((in_bpp == 15) && (out_bpp == 24))
{
pixel = in_color;
SPLITCOLOR15(red, green, blue, pixel);
pixel = COLOR24BGR(red, green, blue);
return pixel;
}
if ((in_bpp == 16) && (out_bpp == 16))
{
return in_color;
}
if ((in_bpp == 16) && (out_bpp == 24))
{
pixel = in_color;
SPLITCOLOR16(red, green, blue, pixel);
pixel = COLOR24BGR(red, green, blue);
return pixel;
}
if ((in_bpp == 24) && (out_bpp == 24))
{
return in_color;
}
return 0;
}