/[rdesktop]/sourceforge.net/trunk/rdesktop/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/trunk/rdesktop/orders.c

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

revision 207 by matthewc, Thu Sep 26 14:26:46 2002 UTC revision 831 by jdmeijer, Tue Mar 8 00:43:10 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-2002     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
# Line 54  rdp_in_present(STREAM s, uint32 * presen Line 55  rdp_in_present(STREAM s, uint32 * presen
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 += (signed char) change;                  *coord += change;
66          }          }
67          else          else
68          {          {
# Line 69  rdp_in_coord(STREAM s, uint16 * coord, B Line 70  rdp_in_coord(STREAM s, uint16 * coord, B
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 */
# Line 263  process_line(STREAM s, LINE_ORDER * os, Line 287  process_line(STREAM s, LINE_ORDER * os,
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->pen.colour));                 os->opcode, os->startx, os->starty, os->endx, os->endy, os->pen.colour));
292    
293          if (os->opcode < 0x01 || os->opcode > 0x10)          if (os->opcode < 0x01 || os->opcode > 0x10)
# Line 279  process_line(STREAM s, LINE_ORDER * os, Line 303  process_line(STREAM s, LINE_ORDER * os,
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 292  process_rect(STREAM s, RECT_ORDER * os, Line 317  process_rect(STREAM s, RECT_ORDER * os,
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            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));          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    
# Line 440  process_triblt(STREAM s, TRIBLT_ORDER * Line 480  process_triblt(STREAM s, TRIBLT_ORDER *
480                    bitmap, os->srcx, os->srcy, &os->brush, os->bgcolour, os->fgcolour);                    bitmap, os->srcx, os->srcy, &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 */
# Line 536  process_polyline(STREAM s, POLYLINE_ORDE Line 722  process_polyline(STREAM s, POLYLINE_ORDE
722          }          }
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(os->opcode - 1, 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(os->opcode - 1, 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 */  /* Process a text order */
796  static void  static void
797  process_text2(STREAM s, TEXT2_ORDER * os, uint32 present, BOOL delta)  process_text2(STREAM s, TEXT2_ORDER * os, uint32 present, BOOL delta)
# Line 584  process_text2(STREAM s, TEXT2_ORDER * os Line 840  process_text2(STREAM s, TEXT2_ORDER * os
840          if (present & 0x002000)          if (present & 0x002000)
841                  in_uint16_le(s, os->boxbottom);                  in_uint16_le(s, os->boxbottom);
842    
843            /*
844             * Unknown members, seen when connecting to a session that was disconnected with
845             * mstsc and with wintach's spreadsheet test.
846             */
847            if (present & 0x004000)
848                    in_uint8s(s, 1);
849    
850            if (present & 0x008000)
851                    in_uint8s(s, 1);
852    
853            if (present & 0x010000)
854            {
855                    in_uint8s(s, 1);        /* guessing the length here */
856                    warning("Unknown order state member (0x010000) in text2 order.\n");
857            }
858    
859            if (present & 0x020000)
860                    in_uint8s(s, 4);
861    
862            if (present & 0x040000)
863                    in_uint8s(s, 4);
864    
865          if (present & 0x080000)          if (present & 0x080000)
866                  in_uint16_le(s, os->x);                  in_uint16_le(s, os->x);
867    
# Line 620  process_raw_bmpcache(STREAM s) Line 898  process_raw_bmpcache(STREAM s)
898  {  {
899          HBITMAP bitmap;          HBITMAP bitmap;
900          uint16 cache_idx, bufsize;          uint16 cache_idx, bufsize;
901          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp, Bpp;
902          uint8 *data, *inverted;          uint8 *data, *inverted;
903          int y;          int y;
904    
# Line 629  process_raw_bmpcache(STREAM s) Line 907  process_raw_bmpcache(STREAM s)
907          in_uint8(s, width);          in_uint8(s, width);
908          in_uint8(s, height);          in_uint8(s, height);
909          in_uint8(s, bpp);          in_uint8(s, bpp);
910            Bpp = (bpp + 7) / 8;
911          in_uint16_le(s, bufsize);          in_uint16_le(s, bufsize);
912          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
913          in_uint8p(s, data, bufsize);          in_uint8p(s, data, bufsize);
914    
915          DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));          DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
916          inverted = xmalloc(width * height);          inverted = (uint8 *) xmalloc(width * height * Bpp);
917          for (y = 0; y < height; y++)          for (y = 0; y < height; y++)
918          {          {
919                  memcpy(&inverted[(height - y - 1) * width], &data[y * width], width);                  memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
920                           width * Bpp);
921          }          }
922    
923          bitmap = ui_create_bitmap(width, height, inverted);          bitmap = ui_create_bitmap(width, height, inverted);
# Line 651  process_bmpcache(STREAM s) Line 931  process_bmpcache(STREAM s)
931  {  {
932          HBITMAP bitmap;          HBITMAP bitmap;
933          uint16 cache_idx, size;          uint16 cache_idx, size;
934          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp, Bpp;
935          uint8 *data, *bmpdata;          uint8 *data, *bmpdata;
936            uint16 bufsize, pad2, row_size, final_size;
937            uint8 pad1;
938    
939            pad2 = row_size = final_size = 0xffff;  /* Shut the compiler up */
940    
941          in_uint8(s, cache_id);          in_uint8(s, cache_id);
942          in_uint8s(s, 1);        /* pad */          in_uint8(s, pad1);      /* pad */
943          in_uint8(s, width);          in_uint8(s, width);
944          in_uint8(s, height);          in_uint8(s, height);
945          in_uint8(s, bpp);          in_uint8(s, bpp);
946          in_uint8s(s, 2);        /* bufsize */          Bpp = (bpp + 7) / 8;
947            in_uint16_le(s, bufsize);       /* bufsize */
948          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
949          in_uint8s(s, 2);        /* pad */  
950          in_uint16_le(s, size);          if (g_use_rdp5)
951          in_uint8s(s, 4);        /* row_size, final_size */          {
952                    size = bufsize;
953            }
954            else
955            {
956    
957                    /* Begin compressedBitmapData */
958                    in_uint16_le(s, pad2);  /* pad */
959                    in_uint16_le(s, size);
960                    /*      in_uint8s(s, 4);  *//* row_size, final_size */
961                    in_uint16_le(s, row_size);
962                    in_uint16_le(s, final_size);
963    
964            }
965          in_uint8p(s, data, size);          in_uint8p(s, data, size);
966    
967          DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));          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));
968    
969          bmpdata = xmalloc(width * height);          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
970    
971          if (bitmap_decompress(bmpdata, width, height, data, size))          if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
972          {          {
973                  bitmap = ui_create_bitmap(width, height, bmpdata);                  bitmap = ui_create_bitmap(width, height, bmpdata);
974                  cache_put_bitmap(cache_id, cache_idx, bitmap);                  cache_put_bitmap(cache_id, cache_idx, bitmap);
975          }          }
976            else
977            {
978                    DEBUG(("Failed to decompress bitmap data\n"));
979            }
980    
981            xfree(bmpdata);
982    }
983    
984    /* Process a bitmap cache v2 order */
985    static void
986    process_bmpcache2(STREAM s, uint16 flags, BOOL compressed)
987    {
988            HBITMAP bitmap;
989            int y;
990            uint8 cache_id, cache_idx_low, width, height, Bpp;
991            uint16 cache_idx, bufsize;
992            uint8 *data, *bmpdata, *bitmap_id;
993    
994            bitmap_id = NULL;       /* prevent compiler warning */
995            cache_id = flags & ID_MASK;
996            Bpp = ((flags & MODE_MASK) >> MODE_SHIFT) - 2;
997    
998            if (flags & PERSIST)
999            {
1000                    in_uint8p(s, bitmap_id, 8);
1001            }
1002    
1003            if (flags & SQUARE)
1004            {
1005                    in_uint8(s, width);
1006                    height = width;
1007            }
1008            else
1009            {
1010                    in_uint8(s, width);
1011                    in_uint8(s, height);
1012            }
1013    
1014            in_uint16_be(s, bufsize);
1015            bufsize &= BUFSIZE_MASK;
1016            in_uint8(s, cache_idx);
1017    
1018            if (cache_idx & LONG_FORMAT)
1019            {
1020                    in_uint8(s, cache_idx_low);
1021                    cache_idx = ((cache_idx ^ LONG_FORMAT) << 8) + cache_idx_low;
1022            }
1023    
1024            in_uint8p(s, data, bufsize);
1025    
1026            DEBUG(("BMPCACHE2(compr=%d,flags=%x,cx=%d,cy=%d,id=%d,idx=%d,Bpp=%d,bs=%d)\n",
1027                   compressed, flags, width, height, cache_id, cache_idx, Bpp, bufsize));
1028    
1029            bmpdata = (uint8 *) xmalloc(width * height * Bpp);
1030    
1031            if (compressed)
1032            {
1033                    if (!bitmap_decompress(bmpdata, width, height, data, bufsize, Bpp))
1034                    {
1035                            DEBUG(("Failed to decompress bitmap data\n"));
1036                            xfree(bmpdata);
1037                            return;
1038                    }
1039            }
1040            else
1041            {
1042                    for (y = 0; y < height; y++)
1043                            memcpy(&bmpdata[(height - y - 1) * (width * Bpp)],
1044                                   &data[y * (width * Bpp)], width * Bpp);
1045            }
1046    
1047            bitmap = ui_create_bitmap(width, height, bmpdata);
1048    
1049            if (bitmap)
1050            {
1051                    cache_put_bitmap(cache_id, cache_idx, bitmap);
1052                    if (flags & PERSIST)
1053                            pstcache_save_bitmap(cache_id, cache_idx, bitmap_id, width, height,
1054                                                 width * height * Bpp, bmpdata);
1055            }
1056            else
1057            {
1058                    DEBUG(("process_bmpcache2: ui_create_bitmap failed\n"));
1059            }
1060    
1061          xfree(bmpdata);          xfree(bmpdata);
1062  }  }
# Line 692  process_colcache(STREAM s) Line 1074  process_colcache(STREAM s)
1074          in_uint8(s, cache_id);          in_uint8(s, cache_id);
1075          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
1076    
1077          map.colours = xmalloc(3 * map.ncolours);          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
1078    
1079          for (i = 0; i < map.ncolours; i++)          for (i = 0; i < map.ncolours; i++)
1080          {          {
# Line 746  process_fontcache(STREAM s) Line 1128  process_fontcache(STREAM s)
1128  static void  static void
1129  process_secondary_order(STREAM s)  process_secondary_order(STREAM s)
1130  {  {
1131            /* The length isn't calculated correctly by the server.
1132             * For very compact orders the length becomes negative
1133             * so a signed integer must be used. */
1134          uint16 length;          uint16 length;
1135            uint16 flags;
1136          uint8 type;          uint8 type;
1137          uint8 *next_order;          uint8 *next_order;
1138    
1139          in_uint16_le(s, length);          in_uint16_le(s, length);
1140          in_uint8s(s, 2);        /* flags */          in_uint16_le(s, flags); /* used by bmpcache2 */
1141          in_uint8(s, type);          in_uint8(s, type);
1142    
1143          next_order = s->p + length + 7;          next_order = s->p + (sint16) length + 7;
1144    
1145          switch (type)          switch (type)
1146          {          {
# Line 774  process_secondary_order(STREAM s) Line 1160  process_secondary_order(STREAM s)
1160                          process_fontcache(s);                          process_fontcache(s);
1161                          break;                          break;
1162    
1163                    case RDP_ORDER_RAW_BMPCACHE2:
1164                            process_bmpcache2(s, flags, False);     /* uncompressed */
1165                            break;
1166    
1167                    case RDP_ORDER_BMPCACHE2:
1168                            process_bmpcache2(s, flags, True);      /* compressed */
1169                            break;
1170    
1171                  default:                  default:
1172                          unimpl("secondary order %d\n", type);                          unimpl("secondary order %d\n", type);
1173          }          }
# Line 783  process_secondary_order(STREAM s) Line 1177  process_secondary_order(STREAM s)
1177    
1178  /* Process an order PDU */  /* Process an order PDU */
1179  void  void
1180  process_orders(STREAM s)  process_orders(STREAM s, uint16 num_orders)
1181  {  {
1182          RDP_ORDER_STATE *os = &order_state;          RDP_ORDER_STATE *os = &g_order_state;
1183          uint32 present;          uint32 present;
         uint16 num_orders;  
1184          uint8 order_flags;          uint8 order_flags;
1185          int size, processed = 0;          int size, processed = 0;
1186          BOOL delta;          BOOL delta;
1187    
         in_uint8s(s, 2);        /* pad */  
         in_uint16_le(s, num_orders);  
         in_uint8s(s, 2);        /* pad */  
   
1188          while (processed < num_orders)          while (processed < num_orders)
1189          {          {
1190                  in_uint8(s, order_flags);                  in_uint8(s, order_flags);
# Line 827  process_orders(STREAM s) Line 1216  process_orders(STREAM s)
1216                                  case RDP_ORDER_PATBLT:                                  case RDP_ORDER_PATBLT:
1217                                  case RDP_ORDER_MEMBLT:                                  case RDP_ORDER_MEMBLT:
1218                                  case RDP_ORDER_LINE:                                  case RDP_ORDER_LINE:
1219                                    case RDP_ORDER_POLYGON2:
1220                                    case RDP_ORDER_ELLIPSE2:
1221                                          size = 2;                                          size = 2;
1222                                          break;                                          break;
1223    
# Line 884  process_orders(STREAM s) Line 1275  process_orders(STREAM s)
1275                                          process_triblt(s, &os->triblt, present, delta);                                          process_triblt(s, &os->triblt, present, delta);
1276                                          break;                                          break;
1277    
1278                                    case RDP_ORDER_POLYGON:
1279                                            process_polygon(s, &os->polygon, present, delta);
1280                                            break;
1281    
1282                                    case RDP_ORDER_POLYGON2:
1283                                            process_polygon2(s, &os->polygon2, present, delta);
1284                                            break;
1285    
1286                                  case RDP_ORDER_POLYLINE:                                  case RDP_ORDER_POLYLINE:
1287                                          process_polyline(s, &os->polyline, present, delta);                                          process_polyline(s, &os->polyline, present, delta);
1288                                          break;                                          break;
1289    
1290                                    case RDP_ORDER_ELLIPSE:
1291                                            process_ellipse(s, &os->ellipse, present, delta);
1292                                            break;
1293    
1294                                    case RDP_ORDER_ELLIPSE2:
1295                                            process_ellipse2(s, &os->ellipse2, present, delta);
1296                                            break;
1297    
1298                                  case RDP_ORDER_TEXT2:                                  case RDP_ORDER_TEXT2:
1299                                          process_text2(s, &os->text2, present, delta);                                          process_text2(s, &os->text2, present, delta);
1300                                          break;                                          break;
# Line 903  process_orders(STREAM s) Line 1310  process_orders(STREAM s)
1310    
1311                  processed++;                  processed++;
1312          }          }
1313    #if 0
1314            /* not true when RDP_COMPRESSION is set */
1315            if (s->p != g_next_packet)
1316                    error("%d bytes remaining\n", (int) (g_next_packet - s->p));
1317    #endif
1318    
         if (s->p != next_packet)  
                 error("%d bytes remaining\n", (int) (next_packet - s->p));  
1319  }  }
1320    
1321  /* Reset order state */  /* Reset order state */
1322  void  void
1323  reset_order_state(void)  reset_order_state(void)
1324  {  {
1325          memset(&order_state, 0, sizeof(order_state));          memset(&g_order_state, 0, sizeof(g_order_state));
1326          order_state.order_type = RDP_ORDER_PATBLT;          g_order_state.order_type = RDP_ORDER_PATBLT;
1327  }  }
Legend:
Removed from v.207  
changed lines
  Added in v.831
  ViewVC Help
Powered by ViewVC 1.1.26