base/applications/mstsc/orders.c

   1 /* -*- c-basic-offset: 8 -*-
   2    rdesktop: A Remote Desktop Protocol client.
   3    RDP order processing
   4    Copyright (C) Matthew Chapman 1999-2005
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation, Inc.,
  18    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include <precomp.h>
  22
  23
  24 extern uint8 *g_next_packet;
  25 static RDP_ORDER_STATE g_order_state;
  26 extern BOOL g_use_rdp5;
  27
  28 /* Read field indicating which parameters are present */
  29 static void
  30 rdp_in_present(STREAM s, uint32 * present, uint8 flags, int size)
  31 {
  32         uint8 bits;
  33         int i;
  34
  35         if (flags & RDP_ORDER_SMALL)
  36         {
  37                 size--;
  38         }
  39
  40         if (flags & RDP_ORDER_TINY)
  41         {
  42                 if (size < 2)
  43                         size = 0;
  44                 else
  45                         size -= 2;
  46         }
  47
  48         *present = 0;
  49         for (i = 0; i < size; i++)
  50         {
  51                 in_uint8(s, bits);
  52                 *present |= bits << (i * 8);
  53         }
  54 }
  55
  56 /* Read a co-ordinate (16-bit, or 8-bit delta) */
  57 static void
  58 rdp_in_coord(STREAM s, sint16 * coord, BOOL delta)
  59 {
  60         sint8 change;
  61
  62         if (delta)
  63         {
  64                 in_uint8(s, change);
  65                 *coord += change;
  66         }
  67         else
  68         {
  69                 in_uint16_le(s, *coord);
  70         }
  71 }
  72
  73 /* Parse a delta co-ordinate in polyline/polygon order form */
  74 static int
  75 parse_delta(uint8 * buffer, int *offset)
  76 {
  77         int value = buffer[(*offset)++];
  78         int two_byte = value & 0x80;
  79
  80         if (value & 0x40)       /* sign bit */
  81                 value |= ~0x3f;
  82         else
  83                 value &= 0x3f;
  84
  85         if (two_byte)
  86                 value = (value << 8) | buffer[(*offset)++];
  87
  88         return value;
  89 }
  90
  91 /* Read a colour entry */
  92 static void
  93 rdp_in_colour(STREAM s, uint32 * colour)
  94 {
  95         uint32 i;
  96         in_uint8(s, i);
  97         *colour = i;
  98         in_uint8(s, i);
  99         *colour |= i << 8;
 100         in_uint8(s, i);
 101         *colour |= i << 16;
 102 }
 103
 104 /* Parse bounds information */
 105 static BOOL
 106 rdp_parse_bounds(STREAM s, BOUNDS * bounds)
 107 {
 108         uint8 present;
 109
 110         in_uint8(s, present);
 111
 112         if (present & 1)
 113                 rdp_in_coord(s, &bounds->left, False);
 114         else if (present & 16)
 115                 rdp_in_coord(s, &bounds->left, True);
 116
 117         if (present & 2)
 118                 rdp_in_coord(s, &bounds->top, False);
 119         else if (present & 32)
 120                 rdp_in_coord(s, &bounds->top, True);
 121
 122         if (present & 4)
 123                 rdp_in_coord(s, &bounds->right, False);
 124         else if (present & 64)
 125                 rdp_in_coord(s, &bounds->right, True);
 126
 127         if (present & 8)
 128                 rdp_in_coord(s, &bounds->bottom, False);
 129         else if (present & 128)
 130                 rdp_in_coord(s, &bounds->bottom, True);
 131
 132         return s_check(s);
 133 }
 134
 135 /* Parse a pen */
 136 static BOOL
 137 rdp_parse_pen(STREAM s, PEN * pen, uint32 present)
 138 {
 139         if (present & 1)
 140                 in_uint8(s, pen->style);
 141
 142         if (present & 2)
 143                 in_uint8(s, pen->width);
 144
 145         if (present & 4)
 146                 rdp_in_colour(s, &pen->colour);
 147
 148         return s_check(s);
 149 }
 150
 151 /* Parse a brush */
 152 static BOOL
 153 rdp_parse_brush(STREAM s, BRUSH * brush, uint32 present)
 154 {
 155         if (present & 1)
 156                 in_uint8(s, brush->xorigin);
 157
 158         if (present & 2)
 159                 in_uint8(s, brush->yorigin);
 160
 161         if (present & 4)
 162                 in_uint8(s, brush->style);
 163
 164         if (present & 8)
 165                 in_uint8(s, brush->pattern[0]);
 166
 167         if (present & 16)
 168                 in_uint8a(s, &brush->pattern[1], 7);
 169
 170         return s_check(s);
 171 }
 172
 173 /* Process a destination blt order */
 174 static void
 175 process_destblt(STREAM s, DESTBLT_ORDER * os, uint32 present, BOOL delta)
 176 {
 177         if (present & 0x01)
 178                 rdp_in_coord(s, &os->x, delta);
 179
 180         if (present & 0x02)
 181                 rdp_in_coord(s, &os->y, delta);
 182
 183         if (present & 0x04)
 184                 rdp_in_coord(s, &os->cx, delta);
 185
 186         if (present & 0x08)
 187                 rdp_in_coord(s, &os->cy, delta);
 188
 189         if (present & 0x10)
 190                 in_uint8(s, os->opcode);
 191
 192         DEBUG(("DESTBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d)\n",
 193                os->opcode, os->x, os->y, os->cx, os->cy));
 194
 195         ui_destblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy);
 196 }
 197
 198 /* Process a pattern blt order */
 199 static void
 200 process_patblt(STREAM s, PATBLT_ORDER * os, uint32 present, BOOL delta)
 201 {
 202         if (present & 0x0001)
 203                 rdp_in_coord(s, &os->x, delta);
 204
 205         if (present & 0x0002)
 206                 rdp_in_coord(s, &os->y, delta);
 207
 208         if (present & 0x0004)
 209                 rdp_in_coord(s, &os->cx, delta);
 210
 211         if (present & 0x0008)
 212                 rdp_in_coord(s, &os->cy, delta);
 213
 214         if (present & 0x0010)
 215                 in_uint8(s, os->opcode);
 216
 217         if (present & 0x0020)
 218                 rdp_in_colour(s, &os->bgcolour);
 219
 220         if (present & 0x0040)
 221                 rdp_in_colour(s, &os->fgcolour);
 222
 223         rdp_parse_brush(s, &os->brush, present >> 7);
 224
 225         DEBUG(("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n", os->opcode, os->x,
 226                os->y, os->cx, os->cy, os->brush.style, os->bgcolour, os->fgcolour));
 227
 228         ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,
 229                   &os->brush, os->bgcolour, os->fgcolour);
 230 }
 231
 232 /* Process a screen blt order */
 233 static void
 234 process_screenblt(STREAM s, SCREENBLT_ORDER * os, uint32 present, BOOL delta)
 235 {
 236         if (present & 0x0001)
 237                 rdp_in_coord(s, &os->x, delta);
 238
 239         if (present & 0x0002)
 240                 rdp_in_coord(s, &os->y, delta);
 241
 242         if (present & 0x0004)
 243                 rdp_in_coord(s, &os->cx, delta);
 244
 245         if (present & 0x0008)
 246                 rdp_in_coord(s, &os->cy, delta);
 247
 248         if (present & 0x0010)
 249                 in_uint8(s, os->opcode);
 250
 251         if (present & 0x0020)
 252                 rdp_in_coord(s, &os->srcx, delta);
 253
 254         if (present & 0x0040)
 255                 rdp_in_coord(s, &os->srcy, delta);
 256
 257         DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",
 258                os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy));
 259
 260         ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);
 261 }
 262
 263 /* Process a line order */
 264 static void
 265 process_line(STREAM s, LINE_ORDER * os, uint32 present, BOOL delta)
 266 {
 267         if (present & 0x0001)
 268                 in_uint16_le(s, os->mixmode);
 269
 270         if (present & 0x0002)
 271                 rdp_in_coord(s, &os->startx, delta);
 272
 273         if (present & 0x0004)
 274                 rdp_in_coord(s, &os->starty, delta);
 275
 276         if (present & 0x0008)
 277                 rdp_in_coord(s, &os->endx, delta);
 278
 279         if (present & 0x0010)
 280                 rdp_in_coord(s, &os->endy, delta);
 281
 282         if (present & 0x0020)
 283                 rdp_in_colour(s, &os->bgcolour);
 284
 285         if (present & 0x0040)
 286                 in_uint8(s, os->opcode);
 287
 288         rdp_parse_pen(s, &os->pen, present >> 7);
 289
 290         DEBUG(("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dy=%d,fg=0x%x)\n",
 291                os->opcode, os->startx, os->starty, os->endx, os->endy, os->pen.colour));
 292
 293         if (os->opcode < 0x01 || os->opcode > 0x10)
 294         {
 295                 error("bad ROP2 0x%x\n", os->opcode);
 296                 return;
 297         }
 298
 299         ui_line(ROP_MINUS_1(os->opcode), os->startx, os->starty, os->endx, os->endy, &os->pen);
 300 }
 301
 302 /* Process an opaque rectangle order */
 303 static void
 304 process_rect(STREAM s, RECT_ORDER * os, uint32 present, BOOL delta)
 305 {
 306         uint32 i;
 307         if (present & 0x01)
 308                 rdp_in_coord(s, &os->x, delta);
 309
 310         if (present & 0x02)
 311                 rdp_in_coord(s, &os->y, delta);
 312
 313         if (present & 0x04)
 314                 rdp_in_coord(s, &os->cx, delta);
 315
 316         if (present & 0x08)
 317                 rdp_in_coord(s, &os->cy, delta);
 318
 319         if (present & 0x10)
 320         {
 321                 in_uint8(s, i);
 322                 os->colour = (os->colour & 0xffffff00) | i;
 323         }
 324
 325         if (present & 0x20)
 326         {
 327                 in_uint8(s, i);
 328                 os->colour = (os->colour & 0xffff00ff) | (i << 8);
 329         }
 330
 331         if (present & 0x40)
 332         {
 333                 in_uint8(s, i);
 334                 os->colour = (os->colour & 0xff00ffff) | (i << 16);
 335         }
 336
 337         DEBUG(("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n", os->x, os->y, os->cx, os->cy, os->colour));
 338
 339         ui_rect(os->x, os->y, os->cx, os->cy, os->colour);
 340 }
 341
 342 /* Process a desktop save order */
 343 static void
 344 process_desksave(STREAM s, DESKSAVE_ORDER * os, uint32 present, BOOL delta)
 345 {
 346         int width, height;
 347
 348         if (present & 0x01)
 349                 in_uint32_le(s, os->offset);
 350
 351         if (present & 0x02)
 352                 rdp_in_coord(s, &os->left, delta);
 353
 354         if (present & 0x04)
 355                 rdp_in_coord(s, &os->top, delta);
 356
 357         if (present & 0x08)
 358                 rdp_in_coord(s, &os->right, delta);
 359
 360         if (present & 0x10)
 361                 rdp_in_coord(s, &os->bottom, delta);
 362
 363         if (present & 0x20)
 364                 in_uint8(s, os->action);
 365
 366         DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",
 367                os->left, os->top, os->right, os->bottom, os->offset, os->action));
 368
 369         width = os->right - os->left + 1;
 370         height = os->bottom - os->top + 1;
 371
 372         if (os->action == 0)
 373                 ui_desktop_save(os->offset, os->left, os->top, width, height);
 374         else
 375                 ui_desktop_restore(os->offset, os->left, os->top, width, height);
 376 }
 377
 378 /* Process a memory blt order */
 379 static void
 380 process_memblt(STREAM s, MEMBLT_ORDER * os, uint32 present, BOOL delta)
 381 {
 382         HBITMAP bitmap;
 383
 384         if (present & 0x0001)
 385         {
 386                 in_uint8(s, os->cache_id);
 387                 in_uint8(s, os->colour_table);
 388         }
 389
 390         if (present & 0x0002)
 391                 rdp_in_coord(s, &os->x, delta);
 392
 393         if (present & 0x0004)
 394                 rdp_in_coord(s, &os->y, delta);
 395
 396         if (present & 0x0008)
 397                 rdp_in_coord(s, &os->cx, delta);
 398
 399         if (present & 0x0010)
 400                 rdp_in_coord(s, &os->cy, delta);
 401
 402         if (present & 0x0020)
 403                 in_uint8(s, os->opcode);
 404
 405         if (present & 0x0040)
 406                 rdp_in_coord(s, &os->srcx, delta);
 407
 408         if (present & 0x0080)
 409                 rdp_in_coord(s, &os->srcy, delta);
 410
 411         if (present & 0x0100)
 412                 in_uint16_le(s, os->cache_idx);
 413
 414         DEBUG(("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n",
 415                os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx));
 416
 417         bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
 418         if (bitmap == NULL)
 419                 return;
 420
 421         ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy);
 422 }
 423
 424 /* Process a 3-way blt order */
 425 static void
 426 process_triblt(STREAM s, TRIBLT_ORDER * os, uint32 present, BOOL delta)
 427 {
 428         HBITMAP bitmap;
 429
 430         if (present & 0x000001)
 431         {
 432                 in_uint8(s, os->cache_id);
 433                 in_uint8(s, os->colour_table);
 434         }
 435
 436         if (present & 0x000002)
 437                 rdp_in_coord(s, &os->x, delta);
 438
 439         if (present & 0x000004)
 440                 rdp_in_coord(s, &os->y, delta);
 441
 442         if (present & 0x000008)
 443                 rdp_in_coord(s, &os->cx, delta);
 444
 445         if (present & 0x000010)
 446                 rdp_in_coord(s, &os->cy, delta);
 447
 448         if (present & 0x000020)
 449                 in_uint8(s, os->opcode);
 450
 451         if (present & 0x000040)
 452                 rdp_in_coord(s, &os->srcx, delta);
 453
 454         if (present & 0x000080)
 455                 rdp_in_coord(s, &os->srcy, delta);
 456
 457         if (present & 0x000100)
 458                 rdp_in_colour(s, &os->bgcolour);
 459
 460         if (present & 0x000200)
 461                 rdp_in_colour(s, &os->fgcolour);
 462
 463         rdp_parse_brush(s, &os->brush, present >> 10);
 464
 465         if (present & 0x008000)
 466                 in_uint16_le(s, os->cache_idx);
 467
 468         if (present & 0x010000)
 469                 in_uint16_le(s, os->unknown);
 470
 471         DEBUG(("TRIBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
 472                os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx,
 473                os->brush.style, os->bgcolour, os->fgcolour));
 474
 475         bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
 476         if (bitmap == NULL)
 477                 return;
 478
 479         ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,
 480                   bitmap, os->srcx, os->srcy, &os->brush, os->bgcolour, os->fgcolour);
 481 }
 482
 483 /* Process a polygon order */
 484 static void
 485 process_polygon(STREAM s, POLYGON_ORDER * os, uint32 present, BOOL delta)
 486 {
 487         int index, data, next;
 488         uint8 flags = 0;
 489         POINT *points;
 490
 491         if (present & 0x01)
 492                 rdp_in_coord(s, &os->x, delta);
 493
 494         if (present & 0x02)
 495                 rdp_in_coord(s, &os->y, delta);
 496
 497         if (present & 0x04)
 498                 in_uint8(s, os->opcode);
 499
 500         if (present & 0x08)
 501                 in_uint8(s, os->fillmode);
 502
 503         if (present & 0x10)
 504                 rdp_in_colour(s, &os->fgcolour);
 505
 506         if (present & 0x20)
 507                 in_uint8(s, os->npoints);
 508
 509         if (present & 0x40)
 510         {
 511                 in_uint8(s, os->datasize);
 512                 in_uint8a(s, os->data, os->datasize);
 513         }
 514
 515         DEBUG(("POLYGON(x=%d,y=%d,op=0x%x,fm=%d,fg=0x%x,n=%d,sz=%d)\n",
 516                os->x, os->y, os->opcode, os->fillmode, os->fgcolour, os->npoints, os->datasize));
 517
 518         DEBUG(("Data: "));
 519
 520         for (index = 0; index < os->datasize; index++)
 521                 DEBUG(("%02x ", os->data[index]));
 522
 523         DEBUG(("\n"));
 524
 525         if (os->opcode < 0x01 || os->opcode > 0x10)
 526         {
 527                 error("bad ROP2 0x%x\n", os->opcode);
 528                 return;
 529         }
 530
 531         points = (POINT *) xmalloc((os->npoints + 1) * sizeof(POINT));
 532         memset(points, 0, (os->npoints + 1) * sizeof(POINT));
 533
 534         points[0].x = os->x;
 535         points[0].y = os->y;
 536
 537         index = 0;
 538         data = ((os->npoints - 1) / 4) + 1;
 539         for (next = 1; (next <= os->npoints) && (next < 256) && (data < os->datasize); next++)
 540         {
 541                 if ((next - 1) % 4 == 0)
 542                         flags = os->data[index++];
 543
 544                 if (~flags & 0x80)
 545                         points[next].x = parse_delta(os->data, &data);
 546
 547                 if (~flags & 0x40)
 548                         points[next].y = parse_delta(os->data, &data);
 549
 550                 flags <<= 2;
 551         }
 552
 553         if (next - 1 == os->npoints)
 554                 ui_polygon(ROP_MINUS_1(os->opcode), os->fillmode, points, os->npoints + 1, NULL, 0,
 555                            os->fgcolour);
 556         else
 557                 error("polygon parse error\n");
 558
 559         xfree(points);
 560 }
 561
 562 /* Process a polygon2 order */
 563 static void
 564 process_polygon2(STREAM s, POLYGON2_ORDER * os, uint32 present, BOOL delta)
 565 {
 566         int index, data, next;
 567         uint8 flags = 0;
 568         POINT *points;
 569
 570         if (present & 0x0001)
 571                 rdp_in_coord(s, &os->x, delta);
 572
 573         if (present & 0x0002)
 574                 rdp_in_coord(s, &os->y, delta);
 575
 576         if (present & 0x0004)
 577                 in_uint8(s, os->opcode);
 578
 579         if (present & 0x0008)
 580                 in_uint8(s, os->fillmode);
 581
 582         if (present & 0x0010)
 583                 rdp_in_colour(s, &os->bgcolour);
 584
 585         if (present & 0x0020)
 586                 rdp_in_colour(s, &os->fgcolour);
 587
 588         rdp_parse_brush(s, &os->brush, present >> 6);
 589
 590         if (present & 0x0800)
 591                 in_uint8(s, os->npoints);
 592
 593         if (present & 0x1000)
 594         {
 595                 in_uint8(s, os->datasize);
 596                 in_uint8a(s, os->data, os->datasize);
 597         }
 598
 599         DEBUG(("POLYGON2(x=%d,y=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x,n=%d,sz=%d)\n",
 600                os->x, os->y, os->opcode, os->fillmode, os->brush.style, os->bgcolour, os->fgcolour,
 601                os->npoints, os->datasize));
 602
 603         DEBUG(("Data: "));
 604
 605         for (index = 0; index < os->datasize; index++)
 606                 DEBUG(("%02x ", os->data[index]));
 607
 608         DEBUG(("\n"));
 609
 610         if (os->opcode < 0x01 || os->opcode > 0x10)
 611         {
 612                 error("bad ROP2 0x%x\n", os->opcode);
 613                 return;
 614         }
 615
 616         points = (POINT *) xmalloc((os->npoints + 1) * sizeof(POINT));
 617         memset(points, 0, (os->npoints + 1) * sizeof(POINT));
 618
 619         points[0].x = os->x;
 620         points[0].y = os->y;
 621
 622         index = 0;
 623         data = ((os->npoints - 1) / 4) + 1;
 624         for (next = 1; (next <= os->npoints) && (next < 256) && (data < os->datasize); next++)
 625         {
 626                 if ((next - 1) % 4 == 0)
 627                         flags = os->data[index++];
 628
 629                 if (~flags & 0x80)
 630                         points[next].x = parse_delta(os->data, &data);
 631
 632                 if (~flags & 0x40)
 633                         points[next].y = parse_delta(os->data, &data);
 634
 635                 flags <<= 2;
 636         }
 637
 638         if (next - 1 == os->npoints)
 639                 ui_polygon(ROP_MINUS_1(os->opcode), os->fillmode, points, os->npoints + 1,
 640                            &os->brush, os->bgcolour, os->fgcolour);
 641         else
 642                 error("polygon2 parse error\n");
 643
 644         xfree(points);
 645 }
 646
 647 /* Process a polyline order */
 648 static void
 649 process_polyline(STREAM s, POLYLINE_ORDER * os, uint32 present, BOOL delta)
 650 {
 651         int index, next, data;
 652         uint8 flags = 0;
 653         PEN pen;
 654         POINT *points;
 655
 656         if (present & 0x01)
 657                 rdp_in_coord(s, &os->x, delta);
 658
 659         if (present & 0x02)
 660                 rdp_in_coord(s, &os->y, delta);
 661
 662         if (present & 0x04)
 663                 in_uint8(s, os->opcode);
 664
 665         if (present & 0x10)
 666                 rdp_in_colour(s, &os->fgcolour);
 667
 668         if (present & 0x20)
 669                 in_uint8(s, os->lines);
 670
 671         if (present & 0x40)
 672         {
 673                 in_uint8(s, os->datasize);
 674                 in_uint8a(s, os->data, os->datasize);
 675         }
 676
 677         DEBUG(("POLYLINE(x=%d,y=%d,op=0x%x,fg=0x%x,n=%d,sz=%d)\n",
 678                os->x, os->y, os->opcode, os->fgcolour, os->lines, os->datasize));
 679
 680         DEBUG(("Data: "));
 681
 682         for (index = 0; index < os->datasize; index++)
 683                 DEBUG(("%02x ", os->data[index]));
 684
 685         DEBUG(("\n"));
 686
 687         if (os->opcode < 0x01 || os->opcode > 0x10)
 688         {
 689                 error("bad ROP2 0x%x\n", os->opcode);
 690                 return;
 691         }
 692
 693         points = (POINT *) xmalloc((os->lines + 1) * sizeof(POINT));
 694         memset(points, 0, (os->lines + 1) * sizeof(POINT));
 695
 696         points[0].x = os->x;
 697         points[0].y = os->y;
 698         pen.style = pen.width = 0;
 699         pen.colour = os->fgcolour;
 700
 701         index = 0;
 702         data = ((os->lines - 1) / 4) + 1;
 703         for (next = 1; (next <= os->lines) && (data < os->datasize); next++)
 704         {
 705                 if ((next - 1) % 4 == 0)
 706                         flags = os->data[index++];
 707
 708                 if (~flags & 0x80)
 709                         points[next].x = parse_delta(os->data, &data);
 710
 711                 if (~flags & 0x40)
 712                         points[next].y = parse_delta(os->data, &data);
 713
 714                 flags <<= 2;
 715         }
 716
 717         if (next - 1 == os->lines)
 718                 ui_polyline(ROP_MINUS_1(os->opcode), points, os->lines + 1, &pen);
 719         else
 720                 error("polyline parse error\n");
 721
 722         xfree(points);
 723 }
 724
 725 /* Process an ellipse order */
 726 static void
 727 process_ellipse(STREAM s, ELLIPSE_ORDER * os, uint32 present, BOOL delta)
 728 {
 729         if (present & 0x01)
 730                 rdp_in_coord(s, &os->left, delta);
 731
 732         if (present & 0x02)
 733                 rdp_in_coord(s, &os->top, delta);
 734
 735         if (present & 0x04)
 736                 rdp_in_coord(s, &os->right, delta);
 737
 738         if (present & 0x08)
 739                 rdp_in_coord(s, &os->bottom, delta);
 740
 741         if (present & 0x10)
 742                 in_uint8(s, os->opcode);
 743
 744         if (present & 0x20)
 745                 in_uint8(s, os->fillmode);
 746
 747         if (present & 0x40)
 748                 rdp_in_colour(s, &os->fgcolour);
 749
 750         DEBUG(("ELLIPSE(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,fg=0x%x)\n", os->left, os->top,
 751                os->right, os->bottom, os->opcode, os->fillmode, os->fgcolour));
 752
 753         ui_ellipse(ROP_MINUS_1(os->opcode), os->fillmode, os->left, os->top, os->right - os->left,
 754                    os->bottom - os->top, NULL, 0, os->fgcolour);
 755 }
 756
 757 /* Process an ellipse2 order */
 758 static void
 759 process_ellipse2(STREAM s, ELLIPSE2_ORDER * os, uint32 present, BOOL delta)
 760 {
 761         if (present & 0x0001)
 762                 rdp_in_coord(s, &os->left, delta);
 763
 764         if (present & 0x0002)
 765                 rdp_in_coord(s, &os->top, delta);
 766
 767         if (present & 0x0004)
 768                 rdp_in_coord(s, &os->right, delta);
 769
 770         if (present & 0x0008)
 771                 rdp_in_coord(s, &os->bottom, delta);
 772
 773         if (present & 0x0010)
 774                 in_uint8(s, os->opcode);
 775
 776         if (present & 0x0020)
 777                 in_uint8(s, os->fillmode);
 778
 779         if (present & 0x0040)
 780                 rdp_in_colour(s, &os->bgcolour);
 781
 782         if (present & 0x0080)
 783                 rdp_in_colour(s, &os->fgcolour);
 784
 785         rdp_parse_brush(s, &os->brush, present >> 8);
 786
 787         DEBUG(("ELLIPSE2(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
 788                os->left, os->top, os->right, os->bottom, os->opcode, os->fillmode, os->brush.style,
 789                os->bgcolour, os->fgcolour));
 790
 791         ui_ellipse(ROP_MINUS_1(os->opcode), os->fillmode, os->left, os->top, os->right - os->left,
 792                    os->bottom - os->top, &os->brush, os->bgcolour, os->fgcolour);
 793 }
 794
 795 /* Process a text order */
 796 static void
 797 process_text2(STREAM s, TEXT2_ORDER * os, uint32 present, BOOL delta)
 798 {
 799         int i;
 800
 801         if (present & 0x000001)
 802                 in_uint8(s, os->font);
 803
 804         if (present & 0x000002)
 805                 in_uint8(s, os->flags);
 806
 807         if (present & 0x000004)
 808                 in_uint8(s, os->opcode);
 809
 810         if (present & 0x000008)
 811                 in_uint8(s, os->mixmode);
 812
 813         if (present & 0x000010)
 814                 rdp_in_colour(s, &os->fgcolour);
 815
 816         if (present & 0x000020)
 817                 rdp_in_colour(s, &os->bgcolour);
 818
 819         if (present & 0x000040)
 820                 in_uint16_le(s, os->clipleft);
 821
 822         if (present & 0x000080)
 823                 in_uint16_le(s, os->cliptop);
 824
 825         if (present & 0x000100)
 826                 in_uint16_le(s, os->clipright);
 827
 828         if (present & 0x000200)
 829                 in_uint16_le(s, os->clipbottom);
 830
 831         if (present & 0x000400)
 832                 in_uint16_le(s, os->boxleft);
 833
 834         if (present & 0x000800)
 835                 in_uint16_le(s, os->boxtop);
 836
 837         if (present & 0x001000)
 838                 in_uint16_le(s, os->boxright);
 839
 840         if (present & 0x002000)
 841                 in_uint16_le(s, os->boxbottom);
 842
 843         rdp_parse_brush(s, &os->brush, present >> 14);
 844
 845         if (present & 0x080000)
 846                 in_uint16_le(s, os->x);
 847
 848         if (present & 0x100000)
 849                 in_uint16_le(s, os->y);
 850
 851         if (present & 0x200000)
 852         {
 853                 in_uint8(s, os->length);
 854                 in_uint8a(s, os->text, os->length);
 855         }
 856
 857         DEBUG(("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,br=%d,bb=%d,bs=%d,bg=0x%x,fg=0x%x,font=%d,fl=0x%x,op=0x%x,mix=%d,n=%d)\n", os->x, os->y, os->clipleft, os->cliptop, os->clipright, os->clipbottom, os->boxleft, os->boxtop, os->boxright, os->boxbottom, os->brush.style, os->bgcolour, os->fgcolour, os->font, os->flags, os->opcode, os->mixmode, os->length));
 858
 859         DEBUG(("Text: "));
 860
 861         for (i = 0; i < os->length; i++)
 862                 DEBUG(("%02x ", os->text[i]));
 863
 864         DEBUG(("\n"));
 865
 866         ui_draw_text(os->font, os->flags, ROP_MINUS_1(os->opcode), os->mixmode, os->x, os->y,
 867                      os->clipleft, os->cliptop, os->clipright - os->clipleft,
 868                      os->clipbottom - os->cliptop, os->boxleft, os->boxtop,
 869                      os->boxright - os->boxleft, os->boxbottom - os->boxtop,
 870                      &os->brush, os->bgcolour, os->fgcolour, os->text, os->length);
 871 }
 872
 873 /* Process a raw bitmap cache order */
 874 static void
 875 process_raw_bmpcache(STREAM s)
 876 {
 877         HBITMAP bitmap;
 878         uint16 cache_idx, bufsize;
 879         uint8 cache_id, width, height, bpp, Bpp;
 880         uint8 *data, *inverted;
 881         int y;
 882
 883         in_uint8(s, cache_id);
 884         in_uint8s(s, 1);        /* pad */
 885         in_uint8(s, width);
 886         in_uint8(s, height);
 887         in_uint8(s, bpp);
 888         Bpp = (bpp + 7) / 8;
 889         in_uint16_le(s, bufsize);
 890         in_uint16_le(s, cache_idx);
 891         in_uint8p(s, data, bufsize);
 892
 893         DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
 894         inverted = (uint8 *) xmalloc(width * height * Bpp);
 895         for (y = 0; y < height; y++)
 896         {
 897                 memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
 898                        width * Bpp);
 899         }
 900
 901         bitmap = ui_create_bitmap(width, height, inverted);
 902         xfree(inverted);
 903         cache_put_bitmap(cache_id, cache_idx, bitmap);
 904 }
 905
 906 /* Process a bitmap cache order */
 907 static void
 908 process_bmpcache(STREAM s)
 909 {
 910         HBITMAP bitmap;
 911         uint16 cache_idx, size;
 912         uint8 cache_id, width, height, bpp, Bpp;
 913         uint8 *data, *bmpdata;
 914         uint16 bufsize, pad2, row_size, final_size;
 915         uint8 pad1;
 916
 917         pad2 = row_size = final_size = 0xffff;  /* Shut the compiler up */
 918
 919         in_uint8(s, cache_id);
 920         in_uint8(s, pad1);      /* pad */
 921         in_uint8(s, width);
 922         in_uint8(s, height);
 923         in_uint8(s, bpp);
 924         Bpp = (bpp + 7) / 8;
 925         in_uint16_le(s, bufsize);       /* bufsize */
 926         in_uint16_le(s, cache_idx);
 927
 928         if (g_use_rdp5)
 929         {
 930                 size = bufsize;
 931         }
 932         else
 933         {
 934
 935                 /* Begin compressedBitmapData */
 936                 in_uint16_le(s, pad2);  /* pad */
 937                 in_uint16_le(s, size);
 938                 /*      in_uint8s(s, 4);  *//* row_size, final_size */
 939                 in_uint16_le(s, row_size);
 940                 in_uint16_le(s, final_size);
 941
 942         }
 943         in_uint8p(s, data, size);
 944
 945         DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d,bpp=%d,size=%d,pad1=%d,bufsize=%d,pad2=%d,rs=%d,fs=%d)\n", width, height, cache_id, cache_idx, bpp, size, pad1, bufsize, pad2, row_size, final_size));
 946
 947         bmpdata = (uint8 *) xmalloc(width * height * Bpp);
 948
 949         if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
 950         {
 951                 bitmap = ui_create_bitmap(width, height, bmpdata);
 952                 cache_put_bitmap(cache_id, cache_idx, bitmap);
 953         }
 954         else
 955         {
 956                 DEBUG(("Failed to decompress bitmap data\n"));
 957         }
 958
 959         xfree(bmpdata);
 960 }
 961
 962 /* Process a bitmap cache v2 order */
 963 static void
 964 process_bmpcache2(STREAM s, uint16 flags, BOOL compressed)
 965 {
 966         HBITMAP bitmap;
 967         int y;
 968         uint8 cache_id, cache_idx_low, width, height, Bpp;
 969         uint16 cache_idx, bufsize;
 970         uint8 *data, *bmpdata, *bitmap_id;
 971
 972         bitmap_id = NULL;       /* prevent compiler warning */
 973         cache_id = flags & ID_MASK;
 974         Bpp = ((flags & MODE_MASK) >> MODE_SHIFT) - 2;
 975
 976         if (flags & PERSIST)
 977         {
 978                 in_uint8p(s, bitmap_id, 8);
 979         }
 980
 981         if (flags & SQUARE)
 982         {
 983                 in_uint8(s, width);
 984                 height = width;
 985         }
 986         else
 987         {
 988                 in_uint8(s, width);
 989                 in_uint8(s, height);
 990         }
 991
 992         in_uint16_be(s, bufsize);
 993         bufsize &= BUFSIZE_MASK;
 994         in_uint8(s, cache_idx);
 995
 996         if (cache_idx & LONG_FORMAT)
 997         {
 998                 in_uint8(s, cache_idx_low);
 999                 cache_idx = ((cache_idx ^ LONG_FORMAT) << 8) + cache_idx_low;
1000         }
1001
1002         in_uint8p(s, data, bufsize);
1003
1004         DEBUG(("BMPCACHE2(compr=%d,flags=%x,cx=%d,cy=%d,id=%d,idx=%d,Bpp=%d,bs=%d)\n",
1005                compressed, flags, width, height, cache_id, cache_idx, Bpp, bufsize));
1006
1007         bmpdata = (uint8 *) xmalloc(width * height * Bpp);
1008
1009         if (compressed)
1010         {
1011                 if (!bitmap_decompress(bmpdata, width, height, data, bufsize, Bpp))
1012                 {
1013                         DEBUG(("Failed to decompress bitmap data\n"));
1014                         xfree(bmpdata);
1015                         return;
1016                 }
1017         }
1018         else
1019         {
1020                 for (y = 0; y < height; y++)
1021                         memcpy(&bmpdata[(height - y - 1) * (width * Bpp)],
1022                                &data[y * (width * Bpp)], width * Bpp);
1023         }
1024
1025         bitmap = ui_create_bitmap(width, height, bmpdata);
1026
1027         if (bitmap)
1028         {
1029                 cache_put_bitmap(cache_id, cache_idx, bitmap);
1030                 if (flags & PERSIST)
1031                         pstcache_save_bitmap(cache_id, cache_idx, bitmap_id, width, height,
1032                                              (uint16) (width * height * Bpp), bmpdata);
1033         }
1034         else
1035         {
1036                 DEBUG(("process_bmpcache2: ui_create_bitmap failed\n"));
1037         }
1038
1039         xfree(bmpdata);
1040 }
1041
1042 /* Process a colourmap cache order */
1043 static void
1044 process_colcache(STREAM s)
1045 {
1046         COLOURENTRY *entry;
1047         COLOURMAP map;
1048         RD_HCOLOURMAP hmap;
1049         uint8 cache_id;
1050         int i;
1051
1052         in_uint8(s, cache_id);
1053         in_uint16_le(s, map.ncolours);
1054
1055         map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
1056
1057         for (i = 0; i < map.ncolours; i++)
1058         {
1059                 entry = &map.colours[i];
1060                 in_uint8(s, entry->blue);
1061                 in_uint8(s, entry->green);
1062                 in_uint8(s, entry->red);
1063                 in_uint8s(s, 1);        /* pad */
1064         }
1065
1066         DEBUG(("COLCACHE(id=%d,n=%d)\n", cache_id, map.ncolours));
1067
1068         hmap = ui_create_colourmap(&map);
1069
1070         if (cache_id)
1071                 ui_set_colourmap(hmap);
1072
1073         xfree(map.colours);
1074 }
1075
1076 /* Process a font cache order */
1077 static void
1078 process_fontcache(STREAM s)
1079 {
1080         RD_HGLYPH bitmap;
1081         uint8 font, nglyphs;
1082         uint16 character, offset, baseline, width, height;
1083         int i, datasize;
1084         uint8 *data;
1085
1086         in_uint8(s, font);
1087         in_uint8(s, nglyphs);
1088
1089         DEBUG(("FONTCACHE(font=%d,n=%d)\n", font, nglyphs));
1090
1091         for (i = 0; i < nglyphs; i++)
1092         {
1093                 in_uint16_le(s, character);
1094                 in_uint16_le(s, offset);
1095                 in_uint16_le(s, baseline);
1096                 in_uint16_le(s, width);
1097                 in_uint16_le(s, height);
1098
1099                 datasize = (height * ((width + 7) / 8) + 3) & ~3;
1100                 in_uint8p(s, data, datasize);
1101
1102                 bitmap = ui_create_glyph(width, height, data);
1103                 cache_put_font(font, character, offset, baseline, width, height, bitmap);
1104         }
1105 }
1106
1107 /* Process a secondary order */
1108 static void
1109 process_secondary_order(STREAM s)
1110 {
1111         /* The length isn't calculated correctly by the server.
1112          * For very compact orders the length becomes negative
1113          * so a signed integer must be used. */
1114         uint16 length;
1115         uint16 flags;
1116         uint8 type;
1117         uint8 *next_order;
1118
1119         in_uint16_le(s, length);
1120         in_uint16_le(s, flags); /* used by bmpcache2 */
1121         in_uint8(s, type);
1122
1123         next_order = s->p + (sint16) length + 7;
1124
1125         switch (type)
1126         {
1127                 case RDP_ORDER_RAW_BMPCACHE:
1128                         process_raw_bmpcache(s);
1129                         break;
1130
1131                 case RDP_ORDER_COLCACHE:
1132                         process_colcache(s);
1133                         break;
1134
1135                 case RDP_ORDER_BMPCACHE:
1136                         process_bmpcache(s);
1137                         break;
1138
1139                 case RDP_ORDER_FONTCACHE:
1140                         process_fontcache(s);
1141                         break;
1142
1143                 case RDP_ORDER_RAW_BMPCACHE2:
1144                         process_bmpcache2(s, flags, False);     /* uncompressed */
1145                         break;
1146
1147                 case RDP_ORDER_BMPCACHE2:
1148                         process_bmpcache2(s, flags, True);      /* compressed */
1149                         break;
1150
1151                 default:
1152                         unimpl("secondary order %d\n", type);
1153         }
1154
1155         s->p = next_order;
1156 }
1157
1158 /* Process an order PDU */
1159 void
1160 process_orders(STREAM s, uint16 num_orders)
1161 {
1162         RDP_ORDER_STATE *os = &g_order_state;
1163         uint32 present;
1164         uint8 order_flags;
1165         int size, processed = 0;
1166         BOOL delta;
1167
1168         while (processed < num_orders)
1169         {
1170                 in_uint8(s, order_flags);
1171
1172                 if (!(order_flags & RDP_ORDER_STANDARD))
1173                 {
1174                         error("order parsing failed\n");
1175                         break;
1176                 }
1177
1178                 if (order_flags & RDP_ORDER_SECONDARY)
1179                 {
1180                         process_secondary_order(s);
1181                 }
1182                 else
1183                 {
1184                         if (order_flags & RDP_ORDER_CHANGE)
1185                         {
1186                                 in_uint8(s, os->order_type);
1187                         }
1188
1189                         switch (os->order_type)
1190                         {
1191                                 case RDP_ORDER_TRIBLT:
1192                                 case RDP_ORDER_TEXT2:
1193                                         size = 3;
1194                                         break;
1195
1196                                 case RDP_ORDER_PATBLT:
1197                                 case RDP_ORDER_MEMBLT:
1198                                 case RDP_ORDER_LINE:
1199                                 case RDP_ORDER_POLYGON2:
1200                                 case RDP_ORDER_ELLIPSE2:
1201                                         size = 2;
1202                                         break;
1203
1204                                 default:
1205                                         size = 1;
1206                         }
1207
1208                         rdp_in_present(s, &present, order_flags, size);
1209
1210                         if (order_flags & RDP_ORDER_BOUNDS)
1211                         {
1212                                 if (!(order_flags & RDP_ORDER_LASTBOUNDS))
1213                                         rdp_parse_bounds(s, &os->bounds);
1214
1215                                 ui_set_clip(os->bounds.left,
1216                                             os->bounds.top,
1217                                             os->bounds.right -
1218                                             os->bounds.left + 1,
1219                                             os->bounds.bottom - os->bounds.top + 1);
1220                         }
1221
1222                         delta = order_flags & RDP_ORDER_DELTA;
1223
1224                         switch (os->order_type)
1225                         {
1226                                 case RDP_ORDER_DESTBLT:
1227                                         process_destblt(s, &os->destblt, present, delta);
1228                                         break;
1229
1230                                 case RDP_ORDER_PATBLT:
1231                                         process_patblt(s, &os->patblt, present, delta);
1232                                         break;
1233
1234                                 case RDP_ORDER_SCREENBLT:
1235                                         process_screenblt(s, &os->screenblt, present, delta);
1236                                         break;
1237
1238                                 case RDP_ORDER_LINE:
1239                                         process_line(s, &os->line, present, delta);
1240                                         break;
1241
1242                                 case RDP_ORDER_RECT:
1243                                         process_rect(s, &os->rect, present, delta);
1244                                         break;
1245
1246                                 case RDP_ORDER_DESKSAVE:
1247                                         process_desksave(s, &os->desksave, present, delta);
1248                                         break;
1249
1250                                 case RDP_ORDER_MEMBLT:
1251                                         process_memblt(s, &os->memblt, present, delta);
1252                                         break;
1253
1254                                 case RDP_ORDER_TRIBLT:
1255                                         process_triblt(s, &os->triblt, present, delta);
1256                                         break;
1257
1258                                 case RDP_ORDER_POLYGON:
1259                                         process_polygon(s, &os->polygon, present, delta);
1260                                         break;
1261
1262                                 case RDP_ORDER_POLYGON2:
1263                                         process_polygon2(s, &os->polygon2, present, delta);
1264                                         break;
1265
1266                                 case RDP_ORDER_POLYLINE:
1267                                         process_polyline(s, &os->polyline, present, delta);
1268                                         break;
1269
1270                                 case RDP_ORDER_ELLIPSE:
1271                                         process_ellipse(s, &os->ellipse, present, delta);
1272                                         break;
1273
1274                                 case RDP_ORDER_ELLIPSE2:
1275                                         process_ellipse2(s, &os->ellipse2, present, delta);
1276                                         break;
1277
1278                                 case RDP_ORDER_TEXT2:
1279                                         process_text2(s, &os->text2, present, delta);
1280                                         break;
1281
1282                                 default:
1283                                         unimpl("order %d\n", os->order_type);
1284                                         return;
1285                         }
1286
1287                         if (order_flags & RDP_ORDER_BOUNDS)
1288                                 ui_reset_clip();
1289                 }
1290
1291                 processed++;
1292         }
1293 #if 0
1294         /* not true when RDP_COMPRESSION is set */
1295         if (s->p != g_next_packet)
1296                 error("%d bytes remaining\n", (int) (g_next_packet - s->p));
1297 #endif
1298
1299 }
1300
1301 /* Reset order state */
1302 void
1303 reset_order_state(void)
1304 {
1305         memset(&g_order_state, 0, sizeof(g_order_state));
1306         g_order_state.order_type = RDP_ORDER_PATBLT;
1307 }