/[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 168 by matthewc, Tue Sep 17 07:23:32 2002 UTC revision 830 by jdmeijer, Tue Mar 8 00:23:02 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
# 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 71  rdp_in_coord(STREAM s, uint16 * coord, B Line 72  rdp_in_coord(STREAM s, uint16 * coord, B
72    
73  /* Read a colour entry */  /* Read a colour entry */
74  static void  static void
75  rdp_in_colour(STREAM s, uint8 * colour)  rdp_in_colour(STREAM s, uint32 * colour)
76  {  {
77          in_uint8(s, *colour);          uint32 i;
78          s->p += 2;          in_uint8(s, i);
79            *colour = i;
80            in_uint8(s, i);
81            *colour |= i << 8;
82            in_uint8(s, i);
83            *colour |= i << 16;
84  }  }
85    
86  /* Parse bounds information */  /* Parse bounds information */
# Line 263  process_line(STREAM s, LINE_ORDER * os, Line 269  process_line(STREAM s, LINE_ORDER * os,
269    
270          rdp_parse_pen(s, &os->pen, present >> 7);          rdp_parse_pen(s, &os->pen, present >> 7);
271    
272          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",
273                 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));
274    
275          if (os->opcode < 0x01 || os->opcode > 0x10)          if (os->opcode < 0x01 || os->opcode > 0x10)
# Line 279  process_line(STREAM s, LINE_ORDER * os, Line 285  process_line(STREAM s, LINE_ORDER * os,
285  static void  static void
286  process_rect(STREAM s, RECT_ORDER * os, uint32 present, BOOL delta)  process_rect(STREAM s, RECT_ORDER * os, uint32 present, BOOL delta)
287  {  {
288            uint32 i;
289          if (present & 0x01)          if (present & 0x01)
290                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
291    
# Line 292  process_rect(STREAM s, RECT_ORDER * os, Line 299  process_rect(STREAM s, RECT_ORDER * os,
299                  rdp_in_coord(s, &os->cy, delta);                  rdp_in_coord(s, &os->cy, delta);
300    
301          if (present & 0x10)          if (present & 0x10)
302                  in_uint8(s, os->colour);          {
303                    in_uint8(s, i);
304                    os->colour = (os->colour & 0xffffff00) | i;
305            }
306    
307            if (present & 0x20)
308            {
309                    in_uint8(s, i);
310                    os->colour = (os->colour & 0xffff00ff) | (i << 8);
311            }
312    
313            if (present & 0x40)
314            {
315                    in_uint8(s, i);
316                    os->colour = (os->colour & 0xff00ffff) | (i << 16);
317            }
318    
319          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));
320    
# Line 584  process_text2(STREAM s, TEXT2_ORDER * os Line 606  process_text2(STREAM s, TEXT2_ORDER * os
606          if (present & 0x002000)          if (present & 0x002000)
607                  in_uint16_le(s, os->boxbottom);                  in_uint16_le(s, os->boxbottom);
608    
609            /*
610             * Unknown members, seen when connecting to a session that was disconnected with
611             * mstsc and with wintach's spreadsheet test.
612             */
613            if (present & 0x004000)
614                    in_uint8s(s, 1);
615    
616            if (present & 0x008000)
617                    in_uint8s(s, 1);
618    
619            if (present & 0x010000)
620            {
621                    in_uint8s(s, 1);        /* guessing the length here */
622                    warning("Unknown order state member (0x010000) in text2 order.\n");
623            }
624    
625            if (present & 0x020000)
626                    in_uint8s(s, 4);
627    
628            if (present & 0x040000)
629                    in_uint8s(s, 4);
630    
631          if (present & 0x080000)          if (present & 0x080000)
632                  in_uint16_le(s, os->x);                  in_uint16_le(s, os->x);
633    
# Line 620  process_raw_bmpcache(STREAM s) Line 664  process_raw_bmpcache(STREAM s)
664  {  {
665          HBITMAP bitmap;          HBITMAP bitmap;
666          uint16 cache_idx, bufsize;          uint16 cache_idx, bufsize;
667          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp, Bpp;
668          uint8 *data, *inverted;          uint8 *data, *inverted;
669          int y;          int y;
670    
# Line 629  process_raw_bmpcache(STREAM s) Line 673  process_raw_bmpcache(STREAM s)
673          in_uint8(s, width);          in_uint8(s, width);
674          in_uint8(s, height);          in_uint8(s, height);
675          in_uint8(s, bpp);          in_uint8(s, bpp);
676            Bpp = (bpp + 7) / 8;
677          in_uint16_le(s, bufsize);          in_uint16_le(s, bufsize);
678          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
679          in_uint8p(s, data, bufsize);          in_uint8p(s, data, bufsize);
680    
681          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));
682          inverted = xmalloc(width * height);          inverted = (uint8 *) xmalloc(width * height * Bpp);
683          for (y = 0; y < height; y++)          for (y = 0; y < height; y++)
684          {          {
685                  memcpy(&inverted[(height - y - 1) * width], &data[y * width], width);                  memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
686                           width * Bpp);
687          }          }
688    
689          bitmap = ui_create_bitmap(width, height, inverted);          bitmap = ui_create_bitmap(width, height, inverted);
# Line 651  process_bmpcache(STREAM s) Line 697  process_bmpcache(STREAM s)
697  {  {
698          HBITMAP bitmap;          HBITMAP bitmap;
699          uint16 cache_idx, size;          uint16 cache_idx, size;
700          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp, Bpp;
701          uint8 *data, *bmpdata;          uint8 *data, *bmpdata;
702            uint16 bufsize, pad2, row_size, final_size;
703            uint8 pad1;
704    
705            pad2 = row_size = final_size = 0xffff;  /* Shut the compiler up */
706    
707          in_uint8(s, cache_id);          in_uint8(s, cache_id);
708          in_uint8s(s, 1);        /* pad */          in_uint8(s, pad1);      /* pad */
709          in_uint8(s, width);          in_uint8(s, width);
710          in_uint8(s, height);          in_uint8(s, height);
711          in_uint8(s, bpp);          in_uint8(s, bpp);
712          in_uint8s(s, 2);        /* bufsize */          Bpp = (bpp + 7) / 8;
713            in_uint16_le(s, bufsize);       /* bufsize */
714          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
715          in_uint8s(s, 2);        /* pad */  
716          in_uint16_le(s, size);          if (g_use_rdp5)
717          in_uint8s(s, 4);        /* row_size, final_size */          {
718                    size = bufsize;
719            }
720            else
721            {
722    
723                    /* Begin compressedBitmapData */
724                    in_uint16_le(s, pad2);  /* pad */
725                    in_uint16_le(s, size);
726                    /*      in_uint8s(s, 4);  *//* row_size, final_size */
727                    in_uint16_le(s, row_size);
728                    in_uint16_le(s, final_size);
729    
730            }
731          in_uint8p(s, data, size);          in_uint8p(s, data, size);
732    
733          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));
734    
735          bmpdata = xmalloc(width * height);          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
736    
737          if (bitmap_decompress(bmpdata, width, height, data, size))          if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
738          {          {
739                  bitmap = ui_create_bitmap(width, height, bmpdata);                  bitmap = ui_create_bitmap(width, height, bmpdata);
740                  cache_put_bitmap(cache_id, cache_idx, bitmap);                  cache_put_bitmap(cache_id, cache_idx, bitmap);
741          }          }
742            else
743            {
744                    DEBUG(("Failed to decompress bitmap data\n"));
745            }
746    
747            xfree(bmpdata);
748    }
749    
750    /* Process a bitmap cache v2 order */
751    static void
752    process_bmpcache2(STREAM s, uint16 flags, BOOL compressed)
753    {
754            HBITMAP bitmap;
755            int y;
756            uint8 cache_id, cache_idx_low, width, height, Bpp;
757            uint16 cache_idx, bufsize;
758            uint8 *data, *bmpdata, *bitmap_id;
759    
760            bitmap_id = NULL;       /* prevent compiler warning */
761            cache_id = flags & ID_MASK;
762            Bpp = ((flags & MODE_MASK) >> MODE_SHIFT) - 2;
763    
764            if (flags & PERSIST)
765            {
766                    in_uint8p(s, bitmap_id, 8);
767            }
768    
769            if (flags & SQUARE)
770            {
771                    in_uint8(s, width);
772                    height = width;
773            }
774            else
775            {
776                    in_uint8(s, width);
777                    in_uint8(s, height);
778            }
779    
780            in_uint16_be(s, bufsize);
781            bufsize &= BUFSIZE_MASK;
782            in_uint8(s, cache_idx);
783    
784            if (cache_idx & LONG_FORMAT)
785            {
786                    in_uint8(s, cache_idx_low);
787                    cache_idx = ((cache_idx ^ LONG_FORMAT) << 8) + cache_idx_low;
788            }
789    
790            in_uint8p(s, data, bufsize);
791    
792            DEBUG(("BMPCACHE2(compr=%d,flags=%x,cx=%d,cy=%d,id=%d,idx=%d,Bpp=%d,bs=%d)\n",
793                   compressed, flags, width, height, cache_id, cache_idx, Bpp, bufsize));
794    
795            bmpdata = (uint8 *) xmalloc(width * height * Bpp);
796    
797            if (compressed)
798            {
799                    if (!bitmap_decompress(bmpdata, width, height, data, bufsize, Bpp))
800                    {
801                            DEBUG(("Failed to decompress bitmap data\n"));
802                            xfree(bmpdata);
803                            return;
804                    }
805            }
806            else
807            {
808                    for (y = 0; y < height; y++)
809                            memcpy(&bmpdata[(height - y - 1) * (width * Bpp)],
810                                   &data[y * (width * Bpp)], width * Bpp);
811            }
812    
813            bitmap = ui_create_bitmap(width, height, bmpdata);
814    
815            if (bitmap)
816            {
817                    cache_put_bitmap(cache_id, cache_idx, bitmap);
818                    if (flags & PERSIST)
819                            pstcache_save_bitmap(cache_id, cache_idx, bitmap_id, width, height,
820                                                 width * height * Bpp, bmpdata);
821            }
822            else
823            {
824                    DEBUG(("process_bmpcache2: ui_create_bitmap failed\n"));
825            }
826    
827          xfree(bmpdata);          xfree(bmpdata);
828  }  }
# Line 692  process_colcache(STREAM s) Line 840  process_colcache(STREAM s)
840          in_uint8(s, cache_id);          in_uint8(s, cache_id);
841          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
842    
843          map.colours = xmalloc(3 * map.ncolours);          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
844    
845          for (i = 0; i < map.ncolours; i++)          for (i = 0; i < map.ncolours; i++)
846          {          {
# Line 746  process_fontcache(STREAM s) Line 894  process_fontcache(STREAM s)
894  static void  static void
895  process_secondary_order(STREAM s)  process_secondary_order(STREAM s)
896  {  {
897            /* The length isn't calculated correctly by the server.
898             * For very compact orders the length becomes negative
899             * so a signed integer must be used. */
900          uint16 length;          uint16 length;
901            uint16 flags;
902          uint8 type;          uint8 type;
903          uint8 *next_order;          uint8 *next_order;
904    
905          in_uint16_le(s, length);          in_uint16_le(s, length);
906          in_uint8s(s, 2);        /* flags */          in_uint16_le(s, flags); /* used by bmpcache2 */
907          in_uint8(s, type);          in_uint8(s, type);
908    
909          next_order = s->p + length + 7;          next_order = s->p + (sint16) length + 7;
910    
911          switch (type)          switch (type)
912          {          {
# Line 774  process_secondary_order(STREAM s) Line 926  process_secondary_order(STREAM s)
926                          process_fontcache(s);                          process_fontcache(s);
927                          break;                          break;
928    
929                    case RDP_ORDER_RAW_BMPCACHE2:
930                            process_bmpcache2(s, flags, False);     /* uncompressed */
931                            break;
932    
933                    case RDP_ORDER_BMPCACHE2:
934                            process_bmpcache2(s, flags, True);      /* compressed */
935                            break;
936    
937                  default:                  default:
938                          unimpl("secondary order %d\n", type);                          unimpl("secondary order %d\n", type);
939          }          }
# Line 783  process_secondary_order(STREAM s) Line 943  process_secondary_order(STREAM s)
943    
944  /* Process an order PDU */  /* Process an order PDU */
945  void  void
946  process_orders(STREAM s)  process_orders(STREAM s, uint16 num_orders)
947  {  {
948          RDP_ORDER_STATE *os = &order_state;          RDP_ORDER_STATE *os = &g_order_state;
949          uint32 present;          uint32 present;
         uint16 num_orders;  
950          uint8 order_flags;          uint8 order_flags;
951          int size, processed = 0;          int size, processed = 0;
952          BOOL delta;          BOOL delta;
953    
         in_uint8s(s, 2);        /* pad */  
         in_uint16_le(s, num_orders);  
         in_uint8s(s, 2);        /* pad */  
   
954          while (processed < num_orders)          while (processed < num_orders)
955          {          {
956                  in_uint8(s, order_flags);                  in_uint8(s, order_flags);
# Line 903  process_orders(STREAM s) Line 1058  process_orders(STREAM s)
1058    
1059                  processed++;                  processed++;
1060          }          }
1061    #if 0
1062            /* not true when RDP_COMPRESSION is set */
1063            if (s->p != g_next_packet)
1064                    error("%d bytes remaining\n", (int) (g_next_packet - s->p));
1065    #endif
1066    
         if (s->p != next_packet)  
                 error("%d bytes remaining\n", (int) (next_packet - s->p));  
1067  }  }
1068    
1069  /* Reset order state */  /* Reset order state */
1070  void  void
1071  reset_order_state()  reset_order_state(void)
1072  {  {
1073          memset(&order_state, 0, sizeof(order_state));          memset(&g_order_state, 0, sizeof(g_order_state));
1074          order_state.order_type = RDP_ORDER_PATBLT;          g_order_state.order_type = RDP_ORDER_PATBLT;
1075  }  }
Legend:
Removed from v.168  
changed lines
  Added in v.830
  ViewVC Help
Powered by ViewVC 1.1.26