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

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

revision 717 by astrand, Thu Jun 17 09:42:58 2004 UTC revision 886 by stargo, Sat Apr 16 11:42:34 2005 UTC
# Line 1  Line 1 
1  /* -*- c-basic-offset: 8 -*-  /* -*- c-basic-offset: 8 -*-
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     Protocol services - RDP layer     Protocol services - RDP layer
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 19  Line 19 
19  */  */
20    
21  #include <time.h>  #include <time.h>
22    #include <errno.h>
23    #include <unistd.h>
24  #include "rdesktop.h"  #include "rdesktop.h"
25    
26    #ifdef HAVE_ICONV
27    #ifdef HAVE_ICONV_H
28    #include <iconv.h>
29    #endif
30    
31    #ifndef ICONV_CONST
32    #define ICONV_CONST ""
33    #endif
34    #endif
35    
36  extern uint16 g_mcs_userid;  extern uint16 g_mcs_userid;
37  extern char g_username[16];  extern char g_username[64];
38    extern char g_codepage[16];
39  extern BOOL g_bitmap_compression;  extern BOOL g_bitmap_compression;
40  extern BOOL g_orders;  extern BOOL g_orders;
41  extern BOOL g_encryption;  extern BOOL g_encryption;
42  extern BOOL g_desktop_save;  extern BOOL g_desktop_save;
43    extern BOOL g_polygon_ellipse_orders;
44  extern BOOL g_use_rdp5;  extern BOOL g_use_rdp5;
45  extern uint16 g_server_rdp_version;  extern uint16 g_server_rdp_version;
46  extern uint32 g_rdp5_performanceflags;  extern uint32 g_rdp5_performanceflags;
# Line 34  extern int g_server_bpp; Line 48  extern int g_server_bpp;
48  extern int g_width;  extern int g_width;
49  extern int g_height;  extern int g_height;
50  extern BOOL g_bitmap_cache;  extern BOOL g_bitmap_cache;
51    extern BOOL g_bitmap_cache_persist_enable;
52    extern BOOL g_rdp_compression;
53    
54  uint8 *g_next_packet;  uint8 *g_next_packet;
55  uint32 g_rdp_shareid;  uint32 g_rdp_shareid;
# Line 44  extern RDPCOMP g_mppc_dict; Line 60  extern RDPCOMP g_mppc_dict;
60  static uint32 g_packetno;  static uint32 g_packetno;
61  #endif  #endif
62    
63    #ifdef HAVE_ICONV
64    static BOOL g_iconv_works = True;
65    #endif
66    
67  /* Receive an RDP packet */  /* Receive an RDP packet */
68  static STREAM  static STREAM
69  rdp_recv(uint8 * type)  rdp_recv(uint8 * type)
70  {  {
71          static STREAM rdp_s;          static STREAM rdp_s;
72          uint16 length, pdu_type;          uint16 length, pdu_type;
73            uint8 rdpver;
74    
75          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
76          {          {
77                  rdp_s = sec_recv();                  rdp_s = sec_recv(&rdpver);
78                  if (rdp_s == NULL)                  if (rdp_s == NULL)
79                          return NULL;                          return NULL;
80                    if (rdpver == 0xff)
81                    {
82                            g_next_packet = rdp_s->end;
83                            *type = 0;
84                            return rdp_s;
85                    }
86                    else if (rdpver != 3)
87                    {
88                            /* rdp5_process should move g_next_packet ok */
89                            rdp5_process(rdp_s);
90                            *type = 0;
91                            return rdp_s;
92                    }
93    
94                  g_next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
95          }          }
# Line 125  rdp_send_data(STREAM s, uint8 data_pdu_t Line 159  rdp_send_data(STREAM s, uint8 data_pdu_t
159  void  void
160  rdp_out_unistr(STREAM s, char *string, int len)  rdp_out_unistr(STREAM s, char *string, int len)
161  {  {
162          int i = 0, j = 0;  #ifdef HAVE_ICONV
163            size_t ibl = strlen(string), obl = len + 2;
164            static iconv_t iconv_h = (iconv_t) - 1;
165            char *pin = string, *pout = (char *) s->p;
166    
167          len += 2;          memset(pout, 0, len + 4);
168    
169          while (i < len)          if (g_iconv_works)
170          {          {
171                  s->p[i++] = string[j++];                  if (iconv_h == (iconv_t) - 1)
172                  s->p[i++] = 0;                  {
173                            size_t i = 1, o = 4;
174                            if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t) - 1)
175                            {
176                                    warning("rdp_out_unistr: iconv_open[%s -> %s] fail %d\n",
177                                            g_codepage, WINDOWS_CODEPAGE, (int) iconv_h);
178    
179                                    g_iconv_works = False;
180                                    rdp_out_unistr(s, string, len);
181                                    return;
182                            }
183                            if (iconv(iconv_h, (ICONV_CONST char **) &pin, &i, &pout, &o) ==
184                                (size_t) - 1)
185                            {
186                                    iconv_close(iconv_h);
187                                    iconv_h = (iconv_t) - 1;
188                                    warning("rdp_out_unistr: iconv(1) fail, errno %d\n", errno);
189    
190                                    g_iconv_works = False;
191                                    rdp_out_unistr(s, string, len);
192                                    return;
193                            }
194                            pin = string;
195                            pout = (char *) s->p;
196                    }
197    
198                    if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
199                    {
200                            iconv_close(iconv_h);
201                            iconv_h = (iconv_t) - 1;
202                            warning("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);
203    
204                            g_iconv_works = False;
205                            rdp_out_unistr(s, string, len);
206                            return;
207                    }
208    
209                    s->p += len + 2;
210    
211          }          }
212            else
213    #endif
214            {
215                    int i = 0, j = 0;
216    
217                    len += 2;
218    
219                    while (i < len)
220                    {
221                            s->p[i++] = string[j++];
222                            s->p[i++] = 0;
223                    }
224    
225          s->p += len;                  s->p += len;
226            }
227  }  }
228    
229  /* Input a string in Unicode  /* Input a string in Unicode
# Line 145  rdp_out_unistr(STREAM s, char *string, i Line 233  rdp_out_unistr(STREAM s, char *string, i
233  int  int
234  rdp_in_unistr(STREAM s, char *string, int uni_len)  rdp_in_unistr(STREAM s, char *string, int uni_len)
235  {  {
236          int i = 0;  #ifdef HAVE_ICONV
237            size_t ibl = uni_len, obl = uni_len;
238            char *pin = (char *) s->p, *pout = string;
239            static iconv_t iconv_h = (iconv_t) - 1;
240    
241          while (i < uni_len / 2)          if (g_iconv_works)
242          {          {
243                  in_uint8a(s, &string[i++], 1);                  if (iconv_h == (iconv_t) - 1)
244                  in_uint8s(s, 1);                  {
245                            if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)
246                            {
247                                    warning("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",
248                                            WINDOWS_CODEPAGE, g_codepage, (int) iconv_h);
249    
250                                    g_iconv_works = False;
251                                    return rdp_in_unistr(s, string, uni_len);
252                            }
253                    }
254    
255                    if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
256                    {
257                            iconv_close(iconv_h);
258                            iconv_h = (iconv_t) - 1;
259                            warning("rdp_in_unistr: iconv fail, errno %d\n", errno);
260    
261                            g_iconv_works = False;
262                            return rdp_in_unistr(s, string, uni_len);
263                    }
264                    return pout - string;
265          }          }
266            else
267    #endif
268            {
269                    int i = 0;
270    
271          return i - 1;                  while (i < uni_len / 2)
272                    {
273                            in_uint8a(s, &string[i++], 1);
274                            in_uint8s(s, 1);
275                    }
276    
277                    return i - 1;
278            }
279  }  }
280    
281    
# Line 366  rdp_send_input(uint32 time, uint16 messa Line 488  rdp_send_input(uint32 time, uint16 messa
488          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
489  }  }
490    
491    /* Inform the server on the contents of the persistent bitmap cache */
492    static void
493    rdp_enum_bmpcache2(void)
494    {
495            STREAM s;
496            HASH_KEY keylist[BMPCACHE2_NUM_PSTCELLS];
497            uint32 num_keys, offset, count, flags;
498    
499            offset = 0;
500            num_keys = pstcache_enumerate(2, keylist);
501    
502            while (offset < num_keys)
503            {
504                    count = MIN(num_keys - offset, 169);
505    
506                    s = rdp_init_data(24 + count * sizeof(HASH_KEY));
507    
508                    flags = 0;
509                    if (offset == 0)
510                            flags |= PDU_FLAG_FIRST;
511                    if (num_keys - offset <= 169)
512                            flags |= PDU_FLAG_LAST;
513    
514                    /* header */
515                    out_uint32_le(s, 0);
516                    out_uint16_le(s, count);
517                    out_uint16_le(s, 0);
518                    out_uint16_le(s, 0);
519                    out_uint16_le(s, 0);
520                    out_uint16_le(s, 0);
521                    out_uint16_le(s, num_keys);
522                    out_uint32_le(s, 0);
523                    out_uint32_le(s, flags);
524    
525                    /* list */
526                    out_uint8a(s, keylist[offset], count * sizeof(HASH_KEY));
527    
528                    s_mark_end(s);
529                    rdp_send_data(s, 0x2b);
530    
531                    offset += 169;
532            }
533    }
534    
535  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
536  static void  static void
537  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 436  rdp_out_order_caps(STREAM s) Line 602  rdp_out_order_caps(STREAM s)
602  {  {
603          uint8 order_caps[32];          uint8 order_caps[32];
604    
   
605          memset(order_caps, 0, 32);          memset(order_caps, 0, 32);
606          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
607          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
608          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
609          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
610            order_caps[4] = 0;      /* triblt */
611          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
612          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
613          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
614          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */          order_caps[11] = (g_desktop_save ? 1 : 0);      /* desksave */
615          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
616          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
617            order_caps[20] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon */
618            order_caps[21] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon2 */
619          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
620            order_caps[25] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse */
621            order_caps[26] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse2 */
622          order_caps[27] = 1;     /* text2 */          order_caps[27] = 1;     /* text2 */
623          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
624          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
# Line 486  rdp_out_bmpcache_caps(STREAM s) Line 656  rdp_out_bmpcache_caps(STREAM s)
656          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
657  }  }
658    
659    /* Output bitmap cache v2 capability set */
660    static void
661    rdp_out_bmpcache2_caps(STREAM s)
662    {
663            uint16 cellsize;
664    
665            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
666            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
667    
668            out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
669    
670            /* Cellsize:
671               01 = 16x16, 02 = 32x32, 03 = 64x64
672               log2(cell size) - 3
673             */
674    
675            cellsize = 0x03;
676    
677            if (g_rdp_compression)
678            {
679                    switch (g_server_bpp)
680                    {
681                            case 24:
682                            case 16:
683                            case 15:
684                                    cellsize = 0x02;
685                                    break;
686                    }
687            }
688    
689            out_uint16_le(s, (0x0000 | (cellsize << 8)));   /* flags? number of caches? */
690    
691            out_uint32_le(s, BMPCACHE2_C0_CELLS);
692            out_uint32_le(s, BMPCACHE2_C1_CELLS);
693            if (pstcache_init(2))
694            {
695                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
696            }
697            else
698            {
699                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
700            }
701            out_uint8s(s, 20);      /* other bitmap caches not used */
702    }
703    
704  /* Output control capability set */  /* Output control capability set */
705  static void  static void
706  rdp_out_control_caps(STREAM s)  rdp_out_control_caps(STREAM s)
# Line 545  rdp_out_colcache_caps(STREAM s) Line 760  rdp_out_colcache_caps(STREAM s)
760          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
761  }  }
762    
763  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
764          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
765          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
766          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
767          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
768          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
769          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
770          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
771          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
772          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
773          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
774          0x0C, 0x00, 0x08, 0x00, 0x01,          0x00, 0x00, 0x00, 0x00
         0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,  
         0x10, 0x00, 0x34, 0x00, 0xFE,  
         0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,  
         0xFE, 0x00, 0x08, 0x00, 0xFE,  
         0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,  
         0xFE, 0x00, 0x80, 0x00, 0xFE,  
         0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,  
         0x02, 0x00, 0x00, 0x00  
775  };  };
776    
777  /* Output unknown capability sets (number 13, 12, 14 and 16) */  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
778    
779    static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
780    
781    static uint8 caps_0x10[] = {
782            0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
783            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
784            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
785            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
786            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
787            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
788    };
789    
790    /* Output unknown capability sets */
791  static void  static void
792  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 * caps)
793  {  {
794          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
795          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
796    
797          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
798  }  }
799    
800  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 588  rdp_send_confirm_active(void) Line 808  rdp_send_confirm_active(void)
808                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
809                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
810                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
811                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
812                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */  +
813                    4 /* w2k fix, why? */ ;
814    
815          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
816    
# Line 608  rdp_send_confirm_active(void) Line 830  rdp_send_confirm_active(void)
830          rdp_out_general_caps(s);          rdp_out_general_caps(s);
831          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
832          rdp_out_order_caps(s);          rdp_out_order_caps(s);
833          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
834          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
835          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
836          rdp_out_control_caps(s);          rdp_out_control_caps(s);
837          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
838          rdp_out_share_caps(s);          rdp_out_share_caps(s);
839          rdp_out_unknown_caps(s);  
840            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
841            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
842            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
843            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
844    
845          s_mark_end(s);          s_mark_end(s);
846          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 666  rdp_process_bitmap_caps(STREAM s) Line 892  rdp_process_bitmap_caps(STREAM s)
892          }          }
893  }  }
894    
895  /* Respond to a demand active PDU */  /* Process server capabilities */
896  static void  void
897  process_demand_active(STREAM s)  rdp_process_server_caps(STREAM s, uint16 length)
898  {  {
899          int n;          int n;
900          uint8 type, *next;          uint8 *next, *start;
901          uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;          uint16 ncapsets, capset_type, capset_length;
902    
903          in_uint32_le(s, g_rdp_shareid);          start = s->p;
         in_uint16_le(s, len_src_descriptor);  
         in_uint16_le(s, len_combined_caps);  
         in_uint8s(s, len_src_descriptor);  
904    
905          in_uint16_le(s, num_capsets);          in_uint16_le(s, ncapsets);
906          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
907    
908          DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));          for (n = 0; n < ncapsets; n++)
   
         for (n = 0; n < num_capsets; n++)  
909          {          {
910                    if (s->p > start + length)
911                            return;
912    
913                  in_uint16_le(s, capset_type);                  in_uint16_le(s, capset_type);
914                  in_uint16_le(s, capset_length);                  in_uint16_le(s, capset_length);
915    
# Line 704  process_demand_active(STREAM s) Line 928  process_demand_active(STREAM s)
928    
929                  s->p = next;                  s->p = next;
930          }          }
931    }
932    
933    /* Respond to a demand active PDU */
934    static void
935    process_demand_active(STREAM s)
936    {
937            uint8 type;
938            uint16 len_src_descriptor, len_combined_caps;
939    
940            in_uint32_le(s, g_rdp_shareid);
941            in_uint16_le(s, len_src_descriptor);
942            in_uint16_le(s, len_combined_caps);
943            in_uint8s(s, len_src_descriptor);
944    
945            DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
946            rdp_process_server_caps(s, len_combined_caps);
947    
948          rdp_send_confirm_active();          rdp_send_confirm_active();
949          rdp_send_synchronise();          rdp_send_synchronise();
# Line 716  process_demand_active(STREAM s) Line 956  process_demand_active(STREAM s)
956    
957          if (g_use_rdp5)          if (g_use_rdp5)
958          {          {
959                    rdp_enum_bmpcache2();
960                  rdp_send_fonts(3);                  rdp_send_fonts(3);
961          }          }
962          else          else
# Line 982  process_data_pdu(STREAM s, uint32 * ext_ Line 1223  process_data_pdu(STREAM s, uint32 * ext_
1223    
1224          if (ctype & RDP_MPPC_COMPRESSED)          if (ctype & RDP_MPPC_COMPRESSED)
1225          {          {
1226                    if (len > RDP_MPPC_DICT_SIZE)
1227                            error("error decompressed packet size exceeds max\n");
1228                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1229                          error("error while decompressing packet\n");                          error("error while decompressing packet\n");
1230    
1231                  //len -= 18;                  /* len -= 18; */
1232    
1233                  /* allocate memory and copy the uncompressed data into the temporary stream */                  /* allocate memory and copy the uncompressed data into the temporary stream */
1234                  ns->data = (uint8 *) xrealloc(ns->data, rlen);                  ns->data = (uint8 *) xrealloc(ns->data, rlen);
# Line 1039  process_data_pdu(STREAM s, uint32 * ext_ Line 1281  process_data_pdu(STREAM s, uint32 * ext_
1281  }  }
1282    
1283  /* Process incoming packets */  /* Process incoming packets */
1284    /* nevers gets out of here till app is done */
1285  void  void
1286  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1287  {  {
1288          uint8 type;          while (rdp_loop(deactivated, ext_disc_reason))
1289          BOOL disc = False;      /* True when a disconnect PDU was received */                  ;
         STREAM s;  
   
         while ((s = rdp_recv(&type)) != NULL)  
         {  
                 switch (type)  
                 {  
                         case RDP_PDU_DEMAND_ACTIVE:  
                                 process_demand_active(s);  
                                 *deactivated = False;  
                                 break;  
   
                         case RDP_PDU_DEACTIVATE:  
                                 DEBUG(("RDP_PDU_DEACTIVATE\n"));  
                                 *deactivated = True;  
                                 break;  
   
                         case RDP_PDU_DATA:  
                                 disc = process_data_pdu(s, ext_disc_reason);  
                                 break;  
   
                         case 0:  
                                 break;  
   
                         default:  
                                 unimpl("PDU %d\n", type);  
                 }  
   
                 if (disc)  
                 {  
                         return;  
                 }  
         }  
         return;  
1290  }  }
1291    
1292  /* used in uiports, processes the rdp packets waiting */  /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1293  BOOL  BOOL
1294  rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1295  {  {
Legend:
Removed from v.717  
changed lines
  Added in v.886
  ViewVC Help
Powered by ViewVC 1.1.26