/[rdesktop]/sourceforge.net/rdesktop/trunk/orders.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/rdesktop/trunk/orders.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 30 by matty, Fri Sep 14 13:51:38 2001 UTC revision 844 by jdmeijer, Thu Mar 10 22:48:15 2005 UTC
# Line 1  Line 1 
1  /*  /* -*- c-basic-offset: 8 -*-
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     RDP order processing     RDP order processing
4     Copyright (C) Matthew Chapman 1999-2001     Copyright (C) Matthew Chapman 1999-2005
5    
6     This program is free software; you can redistribute it and/or modify     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     it under the terms of the GNU General Public License as published by
# Line 21  Line 21 
21  #include "rdesktop.h"  #include "rdesktop.h"
22  #include "orders.h"  #include "orders.h"
23    
24  extern uint8 *next_packet;  extern uint8 *g_next_packet;
25  static RDP_ORDER_STATE order_state;  static RDP_ORDER_STATE g_order_state;
26    extern BOOL g_use_rdp5;
27    
28  /* Read field indicating which parameters are present */  /* Read field indicating which parameters are present */
29  static void  static void
30  rdp_in_present(STREAM s, uint32 *present, uint8 flags, int size)  rdp_in_present(STREAM s, uint32 * present, uint8 flags, int size)
31  {  {
32          uint8 bits;          uint8 bits;
33          int i;          int i;
# Line 54  rdp_in_present(STREAM s, uint32 *present Line 55  rdp_in_present(STREAM s, uint32 *present
55    
56  /* Read a co-ordinate (16-bit, or 8-bit delta) */  /* Read a co-ordinate (16-bit, or 8-bit delta) */
57  static void  static void
58  rdp_in_coord(STREAM s, uint16 *coord, BOOL delta)  rdp_in_coord(STREAM s, sint16 * coord, BOOL delta)
59  {  {
60          uint8 change;          sint8 change;
61    
62          if (delta)          if (delta)
63          {          {
64                  in_uint8(s, change);                  in_uint8(s, change);
65                  *coord += (char) change;                  *coord += change;
66          }          }
67          else          else
68          {          {
# Line 69  rdp_in_coord(STREAM s, uint16 *coord, BO Line 70  rdp_in_coord(STREAM s, uint16 *coord, BO
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 */  /* Read a colour entry */
92  static void  static void
93  rdp_in_colour(STREAM s, uint8 *colour)  rdp_in_colour(STREAM s, uint32 * colour)
94  {  {
95          in_uint8(s, *colour);          uint32 i;
96          s->p += 2;          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 */  /* Parse bounds information */
105  static BOOL  static BOOL
106  rdp_parse_bounds(STREAM s, BOUNDS *bounds)  rdp_parse_bounds(STREAM s, BOUNDS * bounds)
107  {  {
108          uint8 present;          uint8 present;
109    
# Line 110  rdp_parse_bounds(STREAM s, BOUNDS *bound Line 134  rdp_parse_bounds(STREAM s, BOUNDS *bound
134    
135  /* Parse a pen */  /* Parse a pen */
136  static BOOL  static BOOL
137  rdp_parse_pen(STREAM s, PEN *pen, uint32 present)  rdp_parse_pen(STREAM s, PEN * pen, uint32 present)
138  {  {
139          if (present & 1)          if (present & 1)
140                  in_uint8(s, pen->style);                  in_uint8(s, pen->style);
# Line 126  rdp_parse_pen(STREAM s, PEN *pen, uint32 Line 150  rdp_parse_pen(STREAM s, PEN *pen, uint32
150    
151  /* Parse a brush */  /* Parse a brush */
152  static BOOL  static BOOL
153  rdp_parse_brush(STREAM s, BRUSH *brush, uint32 present)  rdp_parse_brush(STREAM s, BRUSH * brush, uint32 present)
154  {  {
155          if (present & 1)          if (present & 1)
156                  in_uint8(s, brush->xorigin);                  in_uint8(s, brush->xorigin);
# Line 148  rdp_parse_brush(STREAM s, BRUSH *brush, Line 172  rdp_parse_brush(STREAM s, BRUSH *brush,
172    
173  /* Process a destination blt order */  /* Process a destination blt order */
174  static void  static void
175  process_destblt(STREAM s, DESTBLT_ORDER *os, uint32 present, BOOL delta)  process_destblt(STREAM s, DESTBLT_ORDER * os, uint32 present, BOOL delta)
176  {  {
177          if (present & 0x01)          if (present & 0x01)
178                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 173  process_destblt(STREAM s, DESTBLT_ORDER Line 197  process_destblt(STREAM s, DESTBLT_ORDER
197    
198  /* Process a pattern blt order */  /* Process a pattern blt order */
199  static void  static void
200  process_patblt(STREAM s, PATBLT_ORDER *os, uint32 present, BOOL delta)  process_patblt(STREAM s, PATBLT_ORDER * os, uint32 present, BOOL delta)
201  {  {
202          if (present & 0x0001)          if (present & 0x0001)
203                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 198  process_patblt(STREAM s, PATBLT_ORDER *o Line 222  process_patblt(STREAM s, PATBLT_ORDER *o
222    
223          rdp_parse_brush(s, &os->brush, present >> 7);          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",          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->opcode, os->x, os->y, os->cx, os->cy,                 os->y, os->cx, os->cy, os->brush.style, os->bgcolour, os->fgcolour));
                os->brush.style, os->bgcolour, os->fgcolour));  
227    
228          ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,          ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,
229                    &os->brush, os->bgcolour, os->fgcolour);                    &os->brush, os->bgcolour, os->fgcolour);
# Line 208  process_patblt(STREAM s, PATBLT_ORDER *o Line 231  process_patblt(STREAM s, PATBLT_ORDER *o
231    
232  /* Process a screen blt order */  /* Process a screen blt order */
233  static void  static void
234  process_screenblt(STREAM s, SCREENBLT_ORDER *os, uint32 present, BOOL delta)  process_screenblt(STREAM s, SCREENBLT_ORDER * os, uint32 present, BOOL delta)
235  {  {
236          if (present & 0x0001)          if (present & 0x0001)
237                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 234  process_screenblt(STREAM s, SCREENBLT_OR Line 257  process_screenblt(STREAM s, SCREENBLT_OR
257          DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",          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));                 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,          ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);
                      os->srcx, os->srcy);  
261  }  }
262    
263  /* Process a line order */  /* Process a line order */
264  static void  static void
265  process_line(STREAM s, LINE_ORDER *os, uint32 present, BOOL delta)  process_line(STREAM s, LINE_ORDER * os, uint32 present, BOOL delta)
266  {  {
267          if (present & 0x0001)          if (present & 0x0001)
268                  in_uint16_le(s, os->mixmode);                  in_uint16_le(s, os->mixmode);
# Line 265  process_line(STREAM s, LINE_ORDER *os, u Line 287  process_line(STREAM s, LINE_ORDER *os, u
287    
288          rdp_parse_pen(s, &os->pen, present >> 7);          rdp_parse_pen(s, &os->pen, present >> 7);
289    
290          DEBUG(("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dx=%d,fg=0x%x)\n",          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->opcode, os->startx, os->starty, os->endx, os->endy, os->pen.colour));
                os->pen.colour));  
292    
293          if (os->opcode < 0x01 || os->opcode > 0x10)          if (os->opcode < 0x01 || os->opcode > 0x10)
294          {          {
# Line 275  process_line(STREAM s, LINE_ORDER *os, u Line 296  process_line(STREAM s, LINE_ORDER *os, u
296                  return;                  return;
297          }          }
298    
299          ui_line(os->opcode - 1, os->startx, os->starty,          ui_line(os->opcode - 1, os->startx, os->starty, os->endx, os->endy, &os->pen);
                 os->endx, os->endy, &os->pen);  
300  }  }
301    
302  /* Process an opaque rectangle order */  /* Process an opaque rectangle order */
303  static void  static void
304  process_rect(STREAM s, RECT_ORDER *os, uint32 present, BOOL delta)  process_rect(STREAM s, RECT_ORDER * os, uint32 present, BOOL delta)
305  {  {
306            uint32 i;
307          if (present & 0x01)          if (present & 0x01)
308                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
309    
# Line 296  process_rect(STREAM s, RECT_ORDER *os, u Line 317  process_rect(STREAM s, RECT_ORDER *os, u
317                  rdp_in_coord(s, &os->cy, delta);                  rdp_in_coord(s, &os->cy, delta);
318    
319          if (present & 0x10)          if (present & 0x10)
320                  in_uint8(s, os->colour);          {
321                    in_uint8(s, i);
322                    os->colour = (os->colour & 0xffffff00) | i;
323            }
324    
325          DEBUG(("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n",          if (present & 0x20)
326                 os->x, os->y, os->cx, os->cy, os->colour));          {
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);          ui_rect(os->x, os->y, os->cx, os->cy, os->colour);
340  }  }
341    
342  /* Process a desktop save order */  /* Process a desktop save order */
343  static void  static void
344  process_desksave(STREAM s, DESKSAVE_ORDER *os, uint32 present, BOOL delta)  process_desksave(STREAM s, DESKSAVE_ORDER * os, uint32 present, BOOL delta)
345  {  {
346          int width, height;          int width, height;
347    
# Line 329  process_desksave(STREAM s, DESKSAVE_ORDE Line 364  process_desksave(STREAM s, DESKSAVE_ORDE
364                  in_uint8(s, os->action);                  in_uint8(s, os->action);
365    
366          DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",          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->left, os->top, os->right, os->bottom, os->offset, os->action));
                os->action));  
368    
369          width = os->right - os->left + 1;          width = os->right - os->left + 1;
370          height = os->bottom - os->top + 1;          height = os->bottom - os->top + 1;
# Line 338  process_desksave(STREAM s, DESKSAVE_ORDE Line 372  process_desksave(STREAM s, DESKSAVE_ORDE
372          if (os->action == 0)          if (os->action == 0)
373                  ui_desktop_save(os->offset, os->left, os->top, width, height);                  ui_desktop_save(os->offset, os->left, os->top, width, height);
374          else          else
375                  ui_desktop_restore(os->offset, os->left, os->top, width,                  ui_desktop_restore(os->offset, os->left, os->top, width, height);
                                    height);  
376  }  }
377    
378  /* Process a memory blt order */  /* Process a memory blt order */
379  static void  static void
380  process_memblt(STREAM s, MEMBLT_ORDER *os, uint32 present, BOOL delta)  process_memblt(STREAM s, MEMBLT_ORDER * os, uint32 present, BOOL delta)
381  {  {
382          HBITMAP bitmap;          HBITMAP bitmap;
383    
# Line 379  process_memblt(STREAM s, MEMBLT_ORDER *o Line 412  process_memblt(STREAM s, MEMBLT_ORDER *o
412                  in_uint16_le(s, os->cache_idx);                  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",          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->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx));
                os->cache_idx));  
416    
417          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
418          if (bitmap == NULL)          if (bitmap == NULL)
419                  return;                  return;
420    
421          ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy,          ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy);
                   bitmap, os->srcx, os->srcy);  
422  }  }
423    
424  /* Process a 3-way blt order */  /* Process a 3-way blt order */
425  static void  static void
426  process_triblt(STREAM s, TRIBLT_ORDER *os, uint32 present, BOOL delta)  process_triblt(STREAM s, TRIBLT_ORDER * os, uint32 present, BOOL delta)
427  {  {
428          HBITMAP bitmap;          HBITMAP bitmap;
429    
# Line 438  process_triblt(STREAM s, TRIBLT_ORDER *o Line 469  process_triblt(STREAM s, TRIBLT_ORDER *o
469                  in_uint16_le(s, os->unknown);                  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",          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->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx,
473                 os->cache_idx, os->brush.style, os->bgcolour, os->fgcolour));                 os->brush.style, os->bgcolour, os->fgcolour));
474    
475          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
476          if (bitmap == NULL)          if (bitmap == NULL)
477                  return;                  return;
478    
479          ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,          ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,
480                    bitmap, os->srcx, os->srcy,                    bitmap, os->srcx, os->srcy, &os->brush, os->bgcolour, os->fgcolour);
                   &os->brush, os->bgcolour, os->fgcolour);  
481  }  }
482    
483  /* Parse a delta co-ordinate in polyline order form */  /* Process a polygon order */
484  static int  static void
485  parse_delta(uint8 *buffer, int *offset)  process_polygon(STREAM s, POLYGON_ORDER * os, uint32 present, BOOL delta)
486  {  {
487          int value = buffer[(*offset)++];          int index, data, next;
488          int two_byte = value & 0x80;          uint8 flags = 0;
489            POINT *points;
490    
491          if (value & 0x40)       /* sign bit */          if (present & 0x01)
492                  value |= ~0x3f;                  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(os->opcode - 1, os->fillmode, points, os->npoints + 1, NULL, 0,
555                               os->fgcolour);
556          else          else
557                  value &= 0x3f;                  error("polygon parse error\n");
558    
559          if (two_byte)          xfree(points);
560                  value = (value << 8) | buffer[(*offset)++];  }
561    
562          return value;  /* 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(os->opcode - 1, 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 */  /* Process a polyline order */
648  static void  static void
649  process_polyline(STREAM s, POLYLINE_ORDER *os, uint32 present, BOOL delta)  process_polyline(STREAM s, POLYLINE_ORDER * os, uint32 present, BOOL delta)
650  {  {
651          int index, line, data;          int index, next, data;
         int x, y, xfrom, yfrom;  
652          uint8 flags = 0;          uint8 flags = 0;
653          PEN pen;          PEN pen;
654            POINT *points;
655    
656          if (present & 0x01)          if (present & 0x01)
657                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 484  process_polyline(STREAM s, POLYLINE_ORDE Line 660  process_polyline(STREAM s, POLYLINE_ORDE
660                  rdp_in_coord(s, &os->y, delta);                  rdp_in_coord(s, &os->y, delta);
661    
662          if (present & 0x04)          if (present & 0x04)
663                  in_uint8(s, os->flags);                  in_uint8(s, os->opcode);
664    
665          if (present & 0x10)          if (present & 0x10)
666                  rdp_in_colour(s, &os->fgcolour);                  rdp_in_colour(s, &os->fgcolour);
# Line 498  process_polyline(STREAM s, POLYLINE_ORDE Line 674  process_polyline(STREAM s, POLYLINE_ORDE
674                  in_uint8a(s, os->data, os->datasize);                  in_uint8a(s, os->data, os->datasize);
675          }          }
676    
677          DEBUG(("POLYLINE(x=%d,y=%d,fl=0x%x,fg=0x%x,n=%d,sz=%d)\n",          DEBUG(("POLYLINE(x=%d,y=%d,op=0x%x,fg=0x%x,n=%d,sz=%d)\n",
678                 os->x, os->y, os->flags, os->fgcolour, os->lines, os->datasize));                 os->x, os->y, os->opcode, os->fgcolour, os->lines, os->datasize));
679    
680          DEBUG(("Data: "));          DEBUG(("Data: "));
681    
# Line 508  process_polyline(STREAM s, POLYLINE_ORDE Line 684  process_polyline(STREAM s, POLYLINE_ORDE
684    
685          DEBUG(("\n"));          DEBUG(("\n"));
686    
687          x = os->x;          if (os->opcode < 0x01 || os->opcode > 0x10)
688          y = os->y;          {
689          pen.style = pen.width = 0;                  error("bad ROP2 0x%x\n", os->opcode);
690          pen.colour = os->fgcolour;                  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    
699          index = 0;          index = 0;
700          data = ((os->lines - 1) / 4) + 1;          data = ((os->lines - 1) / 4) + 1;
701          for (line = 0; (line < os->lines) && (data < os->datasize); line++)          for (next = 1; (next < os->lines) && (data < os->datasize); next++)
702          {          {
703                  xfrom = x;                  if ((next - 1) % 4 == 0)
                 yfrom = y;  
   
                 if (line % 4 == 0)  
704                          flags = os->data[index++];                          flags = os->data[index++];
705    
706                  if ((flags & 0xc0) == 0)                  if (~flags & 0x80)
707                          flags |= 0xc0;  /* none = both */                          points[next].x = parse_delta(os->data, &data);
   
                 if (flags & 0x40)  
                         x += parse_delta(os->data, &data);  
708    
709                  if (flags & 0x80)                  if (~flags & 0x40)
710                          y += parse_delta(os->data, &data);                          points[next].y = parse_delta(os->data, &data);
   
                 ui_line(ROP2_NXOR, xfrom, yfrom, x, y, &pen);  
711    
712                  flags <<= 2;                  flags <<= 2;
713          }          }
714    
715            if (next - 1 == os->lines)
716                    ui_polyline(os->opcode - 1, points, os->lines + 1, &pen);
717            else
718                    error("polyline parse error\n");
719    }
720    
721    /* Process an ellipse order */
722    static void
723    process_ellipse(STREAM s, ELLIPSE_ORDER * os, uint32 present, BOOL delta)
724    {
725            if (present & 0x01)
726                    rdp_in_coord(s, &os->left, delta);
727    
728            if (present & 0x02)
729                    rdp_in_coord(s, &os->top, delta);
730    
731            if (present & 0x04)
732                    rdp_in_coord(s, &os->right, delta);
733    
734            if (present & 0x08)
735                    rdp_in_coord(s, &os->bottom, delta);
736    
737            if (present & 0x10)
738                    in_uint8(s, os->opcode);
739    
740            if (present & 0x20)
741                    in_uint8(s, os->fillmode);
742    
743            if (present & 0x40)
744                    rdp_in_colour(s, &os->fgcolour);
745    
746            DEBUG(("ELLIPSE(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,fg=0x%x)\n", os->left, os->top,
747                   os->right, os->bottom, os->opcode, os->fillmode, os->fgcolour));
748    
749            ui_ellipse(os->opcode - 1, os->fillmode, os->left, os->top, os->right - os->left,
750                       os->bottom - os->top, NULL, 0, os->fgcolour);
751    }
752    
753    /* Process an ellipse2 order */
754    static void
755    process_ellipse2(STREAM s, ELLIPSE2_ORDER * os, uint32 present, BOOL delta)
756    {
757            if (present & 0x0001)
758                    rdp_in_coord(s, &os->left, delta);
759    
760            if (present & 0x0002)
761                    rdp_in_coord(s, &os->top, delta);
762    
763            if (present & 0x0004)
764                    rdp_in_coord(s, &os->right, delta);
765    
766            if (present & 0x0008)
767                    rdp_in_coord(s, &os->bottom, delta);
768    
769            if (present & 0x0010)
770                    in_uint8(s, os->opcode);
771    
772            if (present & 0x0020)
773                    in_uint8(s, os->fillmode);
774    
775            if (present & 0x0040)
776                    rdp_in_colour(s, &os->bgcolour);
777    
778            if (present & 0x0080)
779                    rdp_in_colour(s, &os->fgcolour);
780    
781            rdp_parse_brush(s, &os->brush, present >> 8);
782    
783            DEBUG(("ELLIPSE2(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
784                   os->left, os->top, os->right, os->bottom, os->opcode, os->fillmode, os->brush.style,
785                   os->bgcolour, os->fgcolour));
786    
787            ui_ellipse(os->opcode - 1, os->fillmode, os->left, os->top, os->right - os->left,
788                       os->bottom - os->top, &os->brush, os->bgcolour, os->fgcolour);
789  }  }
790    
791  /* Process a text order */  /* Process a text order */
792  static void  static void
793  process_text2(STREAM s, TEXT2_ORDER *os, uint32 present, BOOL delta)  process_text2(STREAM s, TEXT2_ORDER * os, uint32 present, BOOL delta)
794  {  {
         DATABLOB *entry;  
795          int i;          int i;
796    
797          if (present & 0x000001)          if (present & 0x000001)
# Line 552  process_text2(STREAM s, TEXT2_ORDER *os, Line 801  process_text2(STREAM s, TEXT2_ORDER *os,
801                  in_uint8(s, os->flags);                  in_uint8(s, os->flags);
802    
803          if (present & 0x000004)          if (present & 0x000004)
804                  in_uint8(s, os->unknown);                  in_uint8(s, os->opcode);
805    
806          if (present & 0x000008)          if (present & 0x000008)
807                  in_uint8(s, os->mixmode);                  in_uint8(s, os->mixmode);
# Line 587  process_text2(STREAM s, TEXT2_ORDER *os, Line 836  process_text2(STREAM s, TEXT2_ORDER *os,
836          if (present & 0x002000)          if (present & 0x002000)
837                  in_uint16_le(s, os->boxbottom);                  in_uint16_le(s, os->boxbottom);
838    
839            rdp_parse_brush(s, &os->brush, present >> 14);
840    
841          if (present & 0x080000)          if (present & 0x080000)
842                  in_uint16_le(s, os->x);                  in_uint16_le(s, os->x);
843    
# Line 599  process_text2(STREAM s, TEXT2_ORDER *os, Line 850  process_text2(STREAM s, TEXT2_ORDER *os,
850                  in_uint8a(s, os->text, os->length);                  in_uint8a(s, os->text, os->length);
851          }          }
852    
853          DEBUG(("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,bb=%d,br=%d,fg=0x%x,bg=0x%x,font=%d,fl=0x%x,mix=%d,unk=0x%x,n=%d)\n",          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));
                os->x, os->y, os->clipleft, os->cliptop, os->clipright,  
                os->clipbottom, os->boxleft, os->boxtop, os->boxright,  
                os->boxbottom, os->fgcolour, os->bgcolour, os->font,  
                os->flags, os->mixmode, os->unknown, os->length));  
854    
855          DEBUG(("Text: "));          DEBUG(("Text: "));
856    
# Line 612  process_text2(STREAM s, TEXT2_ORDER *os, Line 859  process_text2(STREAM s, TEXT2_ORDER *os,
859    
860          DEBUG(("\n"));          DEBUG(("\n"));
861    
862          /* Process special cache strings */          ui_draw_text(os->font, os->flags, os->opcode - 1, os->mixmode, os->x, os->y,
863          if ((os->length >= 2) && (os->text[0] == 0xfe))                       os->clipleft, os->cliptop, os->clipright - os->clipleft,
864          {                       os->clipbottom - os->cliptop, os->boxleft, os->boxtop,
865                  entry = cache_get_text(os->text[1]);                       os->boxright - os->boxleft, os->boxbottom - os->boxtop,
866                         &os->brush, os->bgcolour, os->fgcolour, os->text, os->length);
                 if (entry == NULL)  
                         return;  
   
                 memcpy(os->text, entry->data, entry->size);  
                 os->length = entry->size;  
         }  
         else if ((os->length >= 3) && (os->text[os->length - 3] == 0xff))  
         {  
                 os->length -= 3;  
                 cache_put_text(os->text[os->length + 1], os->text,  
                                os->length);  
         }  
   
         ui_draw_text(os->font, os->flags, os->mixmode, os->x, os->y,  
                      os->clipleft, os->cliptop,  
                      os->clipright - os->clipleft,  
                      os->clipbottom - os->cliptop,  
                      os->boxleft, os->boxtop,  
                      os->boxright - os->boxleft,  
                      os->boxbottom - os->boxtop,  
                      os->bgcolour, os->fgcolour, os->text, os->length);  
867  }  }
868    
869  /* Process a raw bitmap cache order */  /* Process a raw bitmap cache order */
# Line 646  process_raw_bmpcache(STREAM s) Line 872  process_raw_bmpcache(STREAM s)
872  {  {
873          HBITMAP bitmap;          HBITMAP bitmap;
874          uint16 cache_idx, bufsize;          uint16 cache_idx, bufsize;
875          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp, Bpp;
876          uint8 *data, *inverted;          uint8 *data, *inverted;
877          int y;          int y;
878    
# Line 655  process_raw_bmpcache(STREAM s) Line 881  process_raw_bmpcache(STREAM s)
881          in_uint8(s, width);          in_uint8(s, width);
882          in_uint8(s, height);          in_uint8(s, height);
883          in_uint8(s, bpp);          in_uint8(s, bpp);
884            Bpp = (bpp + 7) / 8;
885          in_uint16_le(s, bufsize);          in_uint16_le(s, bufsize);
886          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
887          in_uint8p(s, data, bufsize);          in_uint8p(s, data, bufsize);
888    
889          DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n",          DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
890                 width, height, cache_id, cache_idx));          inverted = (uint8 *) xmalloc(width * height * Bpp);
         inverted = xmalloc(width * height);  
891          for (y = 0; y < height; y++)          for (y = 0; y < height; y++)
892          {          {
893                  memcpy(&inverted[(height - y - 1) * width], &data[y * width],                  memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
894                         width);                         width * Bpp);
895          }          }
896    
897          bitmap = ui_create_bitmap(width, height, inverted);          bitmap = ui_create_bitmap(width, height, inverted);
# Line 679  process_bmpcache(STREAM s) Line 905  process_bmpcache(STREAM s)
905  {  {
906          HBITMAP bitmap;          HBITMAP bitmap;
907          uint16 cache_idx, size;          uint16 cache_idx, size;
908          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp, Bpp;
909          uint8 *data, *bmpdata;          uint8 *data, *bmpdata;
910            uint16 bufsize, pad2, row_size, final_size;
911            uint8 pad1;
912    
913            pad2 = row_size = final_size = 0xffff;  /* Shut the compiler up */
914    
915          in_uint8(s, cache_id);          in_uint8(s, cache_id);
916          in_uint8s(s, 1);        /* pad */          in_uint8(s, pad1);      /* pad */
917          in_uint8(s, width);          in_uint8(s, width);
918          in_uint8(s, height);          in_uint8(s, height);
919          in_uint8(s, bpp);          in_uint8(s, bpp);
920          in_uint8s(s, 2);        /* bufsize */          Bpp = (bpp + 7) / 8;
921            in_uint16_le(s, bufsize);       /* bufsize */
922          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
923          in_uint8s(s, 2);        /* pad */  
924          in_uint16_le(s, size);          if (g_use_rdp5)
925          in_uint8s(s, 4);        /* row_size, final_size */          {
926                    size = bufsize;
927            }
928            else
929            {
930    
931                    /* Begin compressedBitmapData */
932                    in_uint16_le(s, pad2);  /* pad */
933                    in_uint16_le(s, size);
934                    /*      in_uint8s(s, 4);  *//* row_size, final_size */
935                    in_uint16_le(s, row_size);
936                    in_uint16_le(s, final_size);
937    
938            }
939          in_uint8p(s, data, size);          in_uint8p(s, data, size);
940    
941          DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n",          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));
                width, height, cache_id, cache_idx));  
942    
943          bmpdata = xmalloc(width * height);          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
944    
945          if (bitmap_decompress(bmpdata, width, height, data, size))          if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
946          {          {
947                  bitmap = ui_create_bitmap(width, height, bmpdata);                  bitmap = ui_create_bitmap(width, height, bmpdata);
948                  cache_put_bitmap(cache_id, cache_idx, bitmap);                  cache_put_bitmap(cache_id, cache_idx, bitmap);
949          }          }
950            else
951            {
952                    DEBUG(("Failed to decompress bitmap data\n"));
953            }
954    
955            xfree(bmpdata);
956    }
957    
958    /* Process a bitmap cache v2 order */
959    static void
960    process_bmpcache2(STREAM s, uint16 flags, BOOL compressed)
961    {
962            HBITMAP bitmap;
963            int y;
964            uint8 cache_id, cache_idx_low, width, height, Bpp;
965            uint16 cache_idx, bufsize;
966            uint8 *data, *bmpdata, *bitmap_id;
967    
968            bitmap_id = NULL;       /* prevent compiler warning */
969            cache_id = flags & ID_MASK;
970            Bpp = ((flags & MODE_MASK) >> MODE_SHIFT) - 2;
971    
972            if (flags & PERSIST)
973            {
974                    in_uint8p(s, bitmap_id, 8);
975            }
976    
977            if (flags & SQUARE)
978            {
979                    in_uint8(s, width);
980                    height = width;
981            }
982            else
983            {
984                    in_uint8(s, width);
985                    in_uint8(s, height);
986            }
987    
988            in_uint16_be(s, bufsize);
989            bufsize &= BUFSIZE_MASK;
990            in_uint8(s, cache_idx);
991    
992            if (cache_idx & LONG_FORMAT)
993            {
994                    in_uint8(s, cache_idx_low);
995                    cache_idx = ((cache_idx ^ LONG_FORMAT) << 8) + cache_idx_low;
996            }
997    
998            in_uint8p(s, data, bufsize);
999    
1000            DEBUG(("BMPCACHE2(compr=%d,flags=%x,cx=%d,cy=%d,id=%d,idx=%d,Bpp=%d,bs=%d)\n",
1001                   compressed, flags, width, height, cache_id, cache_idx, Bpp, bufsize));
1002    
1003            bmpdata = (uint8 *) xmalloc(width * height * Bpp);
1004    
1005            if (compressed)
1006            {
1007                    if (!bitmap_decompress(bmpdata, width, height, data, bufsize, Bpp))
1008                    {
1009                            DEBUG(("Failed to decompress bitmap data\n"));
1010                            xfree(bmpdata);
1011                            return;
1012                    }
1013            }
1014            else
1015            {
1016                    for (y = 0; y < height; y++)
1017                            memcpy(&bmpdata[(height - y - 1) * (width * Bpp)],
1018                                   &data[y * (width * Bpp)], width * Bpp);
1019            }
1020    
1021            bitmap = ui_create_bitmap(width, height, bmpdata);
1022    
1023            if (bitmap)
1024            {
1025                    cache_put_bitmap(cache_id, cache_idx, bitmap);
1026                    if (flags & PERSIST)
1027                            pstcache_save_bitmap(cache_id, cache_idx, bitmap_id, width, height,
1028                                                 width * height * Bpp, bmpdata);
1029            }
1030            else
1031            {
1032                    DEBUG(("process_bmpcache2: ui_create_bitmap failed\n"));
1033            }
1034    
1035          xfree(bmpdata);          xfree(bmpdata);
1036  }  }
# Line 721  process_colcache(STREAM s) Line 1048  process_colcache(STREAM s)
1048          in_uint8(s, cache_id);          in_uint8(s, cache_id);
1049          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
1050    
1051          map.colours = xmalloc(3 * map.ncolours);          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
1052    
1053          for (i = 0; i < map.ncolours; i++)          for (i = 0; i < map.ncolours; i++)
1054          {          {
# Line 767  process_fontcache(STREAM s) Line 1094  process_fontcache(STREAM s)
1094                  in_uint8p(s, data, datasize);                  in_uint8p(s, data, datasize);
1095    
1096                  bitmap = ui_create_glyph(width, height, data);                  bitmap = ui_create_glyph(width, height, data);
1097                  cache_put_font(font, character, offset, baseline,                  cache_put_font(font, character, offset, baseline, width, height, bitmap);
                                width, height, bitmap);  
1098          }          }
1099  }  }
1100    
# Line 776  process_fontcache(STREAM s) Line 1102  process_fontcache(STREAM s)
1102  static void  static void
1103  process_secondary_order(STREAM s)  process_secondary_order(STREAM s)
1104  {  {
1105            /* The length isn't calculated correctly by the server.
1106             * For very compact orders the length becomes negative
1107             * so a signed integer must be used. */
1108          uint16 length;          uint16 length;
1109            uint16 flags;
1110          uint8 type;          uint8 type;
1111          uint8 *next_order;          uint8 *next_order;
1112    
1113          in_uint16_le(s, length);          in_uint16_le(s, length);
1114          in_uint8s(s, 2);        /* flags */          in_uint16_le(s, flags); /* used by bmpcache2 */
1115          in_uint8(s, type);          in_uint8(s, type);
1116    
1117          next_order = s->p + length + 7;          next_order = s->p + (sint16) length + 7;
1118    
1119          switch (type)          switch (type)
1120          {          {
# Line 804  process_secondary_order(STREAM s) Line 1134  process_secondary_order(STREAM s)
1134                          process_fontcache(s);                          process_fontcache(s);
1135                          break;                          break;
1136    
1137                    case RDP_ORDER_RAW_BMPCACHE2:
1138                            process_bmpcache2(s, flags, False);     /* uncompressed */
1139                            break;
1140    
1141                    case RDP_ORDER_BMPCACHE2:
1142                            process_bmpcache2(s, flags, True);      /* compressed */
1143                            break;
1144    
1145                  default:                  default:
1146                          unimpl("secondary order %d\n", type);                          unimpl("secondary order %d\n", type);
1147          }          }
# Line 813  process_secondary_order(STREAM s) Line 1151  process_secondary_order(STREAM s)
1151    
1152  /* Process an order PDU */  /* Process an order PDU */
1153  void  void
1154  process_orders(STREAM s)  process_orders(STREAM s, uint16 num_orders)
1155  {  {
1156          RDP_ORDER_STATE *os = &order_state;          RDP_ORDER_STATE *os = &g_order_state;
1157          uint32 present;          uint32 present;
         uint16 num_orders;  
1158          uint8 order_flags;          uint8 order_flags;
1159          int size, processed = 0;          int size, processed = 0;
1160          BOOL delta;          BOOL delta;
1161    
         in_uint8s(s, 2);        /* pad */  
         in_uint16_le(s, num_orders);  
         in_uint8s(s, 2);        /* pad */  
   
1162          while (processed < num_orders)          while (processed < num_orders)
1163          {          {
1164                  in_uint8(s, order_flags);                  in_uint8(s, order_flags);
# Line 857  process_orders(STREAM s) Line 1190  process_orders(STREAM s)
1190                                  case RDP_ORDER_PATBLT:                                  case RDP_ORDER_PATBLT:
1191                                  case RDP_ORDER_MEMBLT:                                  case RDP_ORDER_MEMBLT:
1192                                  case RDP_ORDER_LINE:                                  case RDP_ORDER_LINE:
1193                                    case RDP_ORDER_POLYGON2:
1194                                    case RDP_ORDER_ELLIPSE2:
1195                                          size = 2;                                          size = 2;
1196                                          break;                                          break;
1197    
# Line 875  process_orders(STREAM s) Line 1210  process_orders(STREAM s)
1210                                              os->bounds.top,                                              os->bounds.top,
1211                                              os->bounds.right -                                              os->bounds.right -
1212                                              os->bounds.left + 1,                                              os->bounds.left + 1,
1213                                              os->bounds.bottom -                                              os->bounds.bottom - os->bounds.top + 1);
                                             os->bounds.top + 1);  
1214                          }                          }
1215    
1216                          delta = order_flags & RDP_ORDER_DELTA;                          delta = order_flags & RDP_ORDER_DELTA;
# Line 884  process_orders(STREAM s) Line 1218  process_orders(STREAM s)
1218                          switch (os->order_type)                          switch (os->order_type)
1219                          {                          {
1220                                  case RDP_ORDER_DESTBLT:                                  case RDP_ORDER_DESTBLT:
1221                                          process_destblt(s, &os->destblt,                                          process_destblt(s, &os->destblt, present, delta);
                                                         present, delta);  
1222                                          break;                                          break;
1223    
1224                                  case RDP_ORDER_PATBLT:                                  case RDP_ORDER_PATBLT:
1225                                          process_patblt(s, &os->patblt,                                          process_patblt(s, &os->patblt, present, delta);
                                                        present, delta);  
1226                                          break;                                          break;
1227    
1228                                  case RDP_ORDER_SCREENBLT:                                  case RDP_ORDER_SCREENBLT:
1229                                          process_screenblt(s, &os->screenblt,                                          process_screenblt(s, &os->screenblt, present, delta);
                                                           present, delta);  
1230                                          break;                                          break;
1231    
1232                                  case RDP_ORDER_LINE:                                  case RDP_ORDER_LINE:
1233                                          process_line(s, &os->line,                                          process_line(s, &os->line, present, delta);
                                                      present, delta);  
1234                                          break;                                          break;
1235    
1236                                  case RDP_ORDER_RECT:                                  case RDP_ORDER_RECT:
1237                                          process_rect(s, &os->rect,                                          process_rect(s, &os->rect, present, delta);
                                                      present, delta);  
1238                                          break;                                          break;
1239    
1240                                  case RDP_ORDER_DESKSAVE:                                  case RDP_ORDER_DESKSAVE:
1241                                          process_desksave(s, &os->desksave,                                          process_desksave(s, &os->desksave, present, delta);
                                                          present, delta);  
1242                                          break;                                          break;
1243    
1244                                  case RDP_ORDER_MEMBLT:                                  case RDP_ORDER_MEMBLT:
1245                                          process_memblt(s, &os->memblt,                                          process_memblt(s, &os->memblt, present, delta);
                                                        present, delta);  
1246                                          break;                                          break;
1247    
1248                                  case RDP_ORDER_TRIBLT:                                  case RDP_ORDER_TRIBLT:
1249                                          process_triblt(s, &os->triblt,                                          process_triblt(s, &os->triblt, present, delta);
1250                                                         present, delta);                                          break;
1251    
1252                                    case RDP_ORDER_POLYGON:
1253                                            process_polygon(s, &os->polygon, present, delta);
1254                                            break;
1255    
1256                                    case RDP_ORDER_POLYGON2:
1257                                            process_polygon2(s, &os->polygon2, present, delta);
1258                                          break;                                          break;
1259    
1260                                  case RDP_ORDER_POLYLINE:                                  case RDP_ORDER_POLYLINE:
1261                                          process_polyline(s, &os->polyline,                                          process_polyline(s, &os->polyline, present, delta);
1262                                                           present, delta);                                          break;
1263    
1264                                    case RDP_ORDER_ELLIPSE:
1265                                            process_ellipse(s, &os->ellipse, present, delta);
1266                                            break;
1267    
1268                                    case RDP_ORDER_ELLIPSE2:
1269                                            process_ellipse2(s, &os->ellipse2, present, delta);
1270                                          break;                                          break;
1271    
1272                                  case RDP_ORDER_TEXT2:                                  case RDP_ORDER_TEXT2:
1273                                          process_text2(s, &os->text2,                                          process_text2(s, &os->text2, present, delta);
                                                       present, delta);  
1274                                          break;                                          break;
1275    
1276                                  default:                                  default:
# Line 944  process_orders(STREAM s) Line 1284  process_orders(STREAM s)
1284    
1285                  processed++;                  processed++;
1286          }          }
1287    #if 0
1288            /* not true when RDP_COMPRESSION is set */
1289            if (s->p != g_next_packet)
1290                    error("%d bytes remaining\n", (int) (g_next_packet - s->p));
1291    #endif
1292    
         if (s->p != next_packet)  
                 error("%d bytes remaining\n", (int) (next_packet - s->p));  
1293  }  }
1294    
1295  /* Reset order state */  /* Reset order state */
1296  void  void
1297  reset_order_state()  reset_order_state(void)
1298  {  {
1299          memset(&order_state, 0, sizeof(order_state));          memset(&g_order_state, 0, sizeof(g_order_state));
1300          order_state.order_type = RDP_ORDER_PATBLT;          g_order_state.order_type = RDP_ORDER_PATBLT;
1301  }  }
Legend:
Removed from v.30  
changed lines
  Added in v.844
  ViewVC Help
Powered by ViewVC 1.1.26