/[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 683 by n-ki, Tue Apr 27 12:55:33 2004 UTC revision 858 by stargo, Sun Mar 13 13:58:23 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    
53  uint8 *g_next_packet;  uint8 *g_next_packet;
54  uint32 g_rdp_shareid;  uint32 g_rdp_shareid;
55    
56  extern RDPCOMP mppc_dict;  extern RDPCOMP g_mppc_dict;
57    
58  #if WITH_DEBUG  #if WITH_DEBUG
59  static uint32 g_packetno;  static uint32 g_packetno;
# Line 50  rdp_recv(uint8 * type) Line 65  rdp_recv(uint8 * type)
65  {  {
66          static STREAM rdp_s;          static STREAM rdp_s;
67          uint16 length, pdu_type;          uint16 length, pdu_type;
68            uint8 rdpver;
69    
70          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
71          {          {
72                  rdp_s = sec_recv();                  rdp_s = sec_recv(&rdpver);
73                  if (rdp_s == NULL)                  if (rdp_s == NULL)
74                          return NULL;                          return NULL;
75                    if (rdpver == 0xff)
76                    {
77                            g_next_packet = rdp_s->end;
78                            *type = 0;
79                            return rdp_s;
80                    }
81                    else if (rdpver != 3)
82                    {
83                            /* rdp5_process should move g_next_packet ok */
84                            rdp5_process(rdp_s);
85                            *type = 0;
86                            return rdp_s;
87                    }
88    
89                  g_next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
90          }          }
# Line 125  rdp_send_data(STREAM s, uint8 data_pdu_t Line 154  rdp_send_data(STREAM s, uint8 data_pdu_t
154  void  void
155  rdp_out_unistr(STREAM s, char *string, int len)  rdp_out_unistr(STREAM s, char *string, int len)
156  {  {
157    #ifdef HAVE_ICONV
158            size_t ibl = strlen(string), obl = len + 2;
159            static iconv_t iconv_h = (iconv_t)-1;
160            char   *pin = string, *pout;
161    #ifdef B_ENDIAN
162            char ss[4096];  // FIXME: global MAX_BUF_SIZE macro need
163    
164            pout = ss;
165    #else
166            pout = s->p;
167    #endif
168    
169            memset(pout, 0, len + 4);
170    
171            if (iconv_h == (iconv_t)-1)
172            {
173                    size_t i = 1, o = 4;
174                    if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t)-1)
175                    {
176                            printf("rdp_out_unistr: iconv_open[%s -> %s] fail %d\n",
177                                    g_codepage, WINDOWS_CODEPAGE, (int)iconv_h);
178                            return;
179                    }
180                    if (iconv(iconv_h, (ICONV_CONST char**)&pin, &i, &pout, &o) == (size_t)-1)
181                    {
182                            iconv_close(iconv_h);
183                            iconv_h = (iconv_t)-1;
184                            printf("rdp_out_unistr: iconv(1) fail, errno %d\n", errno);
185                            return;
186                    }
187                    pin = string; pout = s->p;
188            }
189    
190            if (iconv(iconv_h, (ICONV_CONST char**)&pin, &ibl, &pout, &obl) == (size_t)-1)
191            {
192                    iconv_close(iconv_h);
193                    iconv_h = (iconv_t)-1;
194                    printf("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);
195                    return;
196            }
197    
198    #ifdef B_ENDIAN
199            swab(ss, s->p, len + 4);
200    #endif
201    
202            s->p += len + 2;
203    
204    #else /*HAVE_ICONV undef*/
205          int i = 0, j = 0;          int i = 0, j = 0;
206    
207          len += 2;          len += 2;
# Line 134  rdp_out_unistr(STREAM s, char *string, i Line 211  rdp_out_unistr(STREAM s, char *string, i
211                  s->p[i++] = string[j++];                  s->p[i++] = string[j++];
212                  s->p[i++] = 0;                  s->p[i++] = 0;
213          }          }
214            
215          s->p += len;          s->p += len;
216    #endif
217  }  }
218    
219  /* Input a string in Unicode  /* Input a string in Unicode
# Line 145  rdp_out_unistr(STREAM s, char *string, i Line 223  rdp_out_unistr(STREAM s, char *string, i
223  int  int
224  rdp_in_unistr(STREAM s, char *string, int uni_len)  rdp_in_unistr(STREAM s, char *string, int uni_len)
225  {  {
226    #ifdef HAVE_ICONV
227            size_t ibl = uni_len, obl = uni_len;
228            char *pin, *pout = string;
229            static iconv_t iconv_h = (iconv_t)-1;
230    #ifdef B_ENDIAN
231            char ss[4096];  // FIXME: global MAX_BUF_SIZE macro need
232    
233            swab(s->p, ss, uni_len);
234            pin = ss;
235    #else
236            pin = s->p;
237    #endif
238    
239            if (iconv_h == (iconv_t)-1)
240            {
241                    if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t)-1)
242                    {
243                            printf("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",
244                                    WINDOWS_CODEPAGE, g_codepage, (int)iconv_h);
245                            return 0;
246                    }
247            }
248    
249            if (iconv(iconv_h, (ICONV_CONST char**)&pin, &ibl, &pout, &obl) == (size_t)-1)
250            {
251                    iconv_close(iconv_h);
252                    iconv_h = (iconv_t)-1;
253                    printf("rdp_in_unistr: iconv fail, errno %d\n", errno);
254                    return 0;
255            }
256            return pout - string;
257    #else /* HAVE_ICONV undef */
258          int i = 0;          int i = 0;
259    
260          while (i < uni_len / 2)          while (i < uni_len / 2)
# Line 154  rdp_in_unistr(STREAM s, char *string, in Line 264  rdp_in_unistr(STREAM s, char *string, in
264          }          }
265    
266          return i - 1;          return i - 1;
267    #endif
268  }  }
269    
270    
# Line 176  rdp_send_logon_info(uint32 flags, char * Line 287  rdp_send_logon_info(uint32 flags, char *
287          time_t t = time(NULL);          time_t t = time(NULL);
288          time_t tzone;          time_t tzone;
289    
290    #if 0
291            /* enable rdp compression */
292            /* some problems still exist with rdp5 */
293            flags |= RDP_COMPRESSION;
294    #endif
295    
296          if (!g_use_rdp5 || 1 == g_server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
297          {          {
298                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
299    
 #if 0  
                 /* enable rdp compression */  
                 /* decompression also works with rdp5 */  
                 /* but there are some unknown opcodes */  
                 flags |= RDP_COMPRESSION;  
 #endif  
300                  s = sec_init(sec_flags, 18 + len_domain + len_user + len_password                  s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
301                               + len_program + len_directory + 10);                               + len_program + len_directory + 10);
302    
# Line 366  rdp_send_input(uint32 time, uint16 messa Line 477  rdp_send_input(uint32 time, uint16 messa
477          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
478  }  }
479    
480    /* Inform the server on the contents of the persistent bitmap cache */
481    static void
482    rdp_enum_bmpcache2(void)
483    {
484            STREAM s;
485            HASH_KEY keylist[BMPCACHE2_NUM_PSTCELLS];
486            uint32 num_keys, offset, count, flags;
487    
488            offset = 0;
489            num_keys = pstcache_enumerate(2, keylist);
490    
491            while (offset < num_keys)
492            {
493                    count = MIN(num_keys - offset, 169);
494    
495                    s = rdp_init_data(24 + count * sizeof(HASH_KEY));
496    
497                    flags = 0;
498                    if (offset == 0)
499                            flags |= PDU_FLAG_FIRST;
500                    if (num_keys - offset <= 169)
501                            flags |= PDU_FLAG_LAST;
502    
503                    /* header */
504                    out_uint32_le(s, 0);
505                    out_uint16_le(s, count);
506                    out_uint16_le(s, 0);
507                    out_uint16_le(s, 0);
508                    out_uint16_le(s, 0);
509                    out_uint16_le(s, 0);
510                    out_uint16_le(s, num_keys);
511                    out_uint32_le(s, 0);
512                    out_uint32_le(s, flags);
513    
514                    /* list */
515                    out_uint8a(s, keylist[offset], count * sizeof(HASH_KEY));
516    
517                    s_mark_end(s);
518                    rdp_send_data(s, 0x2b);
519    
520                    offset += 169;
521            }
522    }
523    
524  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
525  static void  static void
526  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 436  rdp_out_order_caps(STREAM s) Line 591  rdp_out_order_caps(STREAM s)
591  {  {
592          uint8 order_caps[32];          uint8 order_caps[32];
593    
   
594          memset(order_caps, 0, 32);          memset(order_caps, 0, 32);
595          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
596          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
597          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
598          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
599            order_caps[4] = 0;      /* triblt */
600          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
601          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
602          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
603          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */          order_caps[11] = (g_desktop_save ? 1 : 0);      /* desksave */
604          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
605          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
606            order_caps[20] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon */
607            order_caps[21] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon2 */
608          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
609            order_caps[25] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse */
610            order_caps[26] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse2 */
611          order_caps[27] = 1;     /* text2 */          order_caps[27] = 1;     /* text2 */
612          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
613          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
# Line 486  rdp_out_bmpcache_caps(STREAM s) Line 645  rdp_out_bmpcache_caps(STREAM s)
645          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
646  }  }
647    
648    /* Output bitmap cache v2 capability set */
649    static void
650    rdp_out_bmpcache2_caps(STREAM s)
651    {
652            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
653            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
654    
655            out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
656    
657            out_uint16_le(s, 0x0300);       /* flags? number of caches? */
658    
659            out_uint32_le(s, BMPCACHE2_C0_CELLS);
660            out_uint32_le(s, BMPCACHE2_C1_CELLS);
661            if (pstcache_init(2))
662            {
663                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
664            }
665            else
666            {
667                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
668            }
669            out_uint8s(s, 20);      /* other bitmap caches not used */
670    }
671    
672  /* Output control capability set */  /* Output control capability set */
673  static void  static void
674  rdp_out_control_caps(STREAM s)  rdp_out_control_caps(STREAM s)
# Line 545  rdp_out_colcache_caps(STREAM s) Line 728  rdp_out_colcache_caps(STREAM s)
728          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
729  }  }
730    
731  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
732          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
733          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
734          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
735          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
736          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
737          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
738          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
739          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
740          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
741          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
742          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  
743  };  };
744    
745  /* Output unknown capability sets (number 13, 12, 14 and 16) */  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
746    
747    static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
748    
749    static uint8 caps_0x10[] = {
750            0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
751            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
752            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
753            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
754            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
755            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
756    };
757    
758    /* Output unknown capability sets */
759  static void  static void
760  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 * caps)
761  {  {
762          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
763          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
764    
765          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
766  }  }
767    
768  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 588  rdp_send_confirm_active(void) Line 776  rdp_send_confirm_active(void)
776                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
777                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
778                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
779                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
780                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */  +
781                    4 /* w2k fix, why? */ ;
782    
783          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
784    
# Line 608  rdp_send_confirm_active(void) Line 798  rdp_send_confirm_active(void)
798          rdp_out_general_caps(s);          rdp_out_general_caps(s);
799          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
800          rdp_out_order_caps(s);          rdp_out_order_caps(s);
801          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
802          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
803          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
804          rdp_out_control_caps(s);          rdp_out_control_caps(s);
805          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
806          rdp_out_share_caps(s);          rdp_out_share_caps(s);
807          rdp_out_unknown_caps(s);  
808            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
809            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
810            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
811            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
812    
813          s_mark_end(s);          s_mark_end(s);
814          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 651  rdp_process_bitmap_caps(STREAM s) Line 845  rdp_process_bitmap_caps(STREAM s)
845           * The server may limit bpp and change the size of the desktop (for           * The server may limit bpp and change the size of the desktop (for
846           * example when shadowing another session).           * example when shadowing another session).
847           */           */
848          g_server_bpp = bpp;          if (g_server_bpp != bpp)
849          g_width = width;          {
850          g_height = height;                  warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);
851                    g_server_bpp = bpp;
852          ui_resize_window();          }
853            if (g_width != width || g_height != height)
854            {
855                    warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
856                            width, height);
857                    g_width = width;
858                    g_height = height;
859                    ui_resize_window();
860            }
861  }  }
862    
863  /* Respond to a demand active PDU */  /* Process server capabilities */
864  static void  void
865  process_demand_active(STREAM s)  rdp_process_server_caps(STREAM s, uint16 length)
866  {  {
867          int n;          int n;
868          uint8 type, *next;          uint8 *next, *start;
869          uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;          uint16 ncapsets, capset_type, capset_length;
870    
871          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);  
872    
873          in_uint16_le(s, num_capsets);          in_uint16_le(s, ncapsets);
874          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
875    
876          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++)  
877          {          {
878                    if (s->p > start + length)
879                            return;
880    
881                  in_uint16_le(s, capset_type);                  in_uint16_le(s, capset_type);
882                  in_uint16_le(s, capset_length);                  in_uint16_le(s, capset_length);
883    
# Line 696  process_demand_active(STREAM s) Line 896  process_demand_active(STREAM s)
896    
897                  s->p = next;                  s->p = next;
898          }          }
899    }
900    
901    /* Respond to a demand active PDU */
902    static void
903    process_demand_active(STREAM s)
904    {
905            uint8 type;
906            uint16 len_src_descriptor, len_combined_caps;
907    
908            in_uint32_le(s, g_rdp_shareid);
909            in_uint16_le(s, len_src_descriptor);
910            in_uint16_le(s, len_combined_caps);
911            in_uint8s(s, len_src_descriptor);
912    
913            DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
914            rdp_process_server_caps(s, len_combined_caps);
915    
916          rdp_send_confirm_active();          rdp_send_confirm_active();
917          rdp_send_synchronise();          rdp_send_synchronise();
# Line 708  process_demand_active(STREAM s) Line 924  process_demand_active(STREAM s)
924    
925          if (g_use_rdp5)          if (g_use_rdp5)
926          {          {
927                    rdp_enum_bmpcache2();
928                  rdp_send_fonts(3);                  rdp_send_fonts(3);
929          }          }
930          else          else
# Line 916  process_update_pdu(STREAM s) Line 1133  process_update_pdu(STREAM s)
1133    
1134          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
1135    
1136            ui_begin_update();
1137          switch (update_type)          switch (update_type)
1138          {          {
1139                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 939  process_update_pdu(STREAM s) Line 1157  process_update_pdu(STREAM s)
1157                  default:                  default:
1158                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
1159          }          }
1160            ui_end_update();
1161  }  }
1162    
1163  /* Process a disconnect PDU */  /* Process a disconnect PDU */
# Line 962  process_data_pdu(STREAM s, uint32 * ext_ Line 1180  process_data_pdu(STREAM s, uint32 * ext_
1180    
1181          uint32 roff, rlen;          uint32 roff, rlen;
1182    
1183          struct stream *ns = &(mppc_dict.ns);          struct stream *ns = &(g_mppc_dict.ns);
         uint8 *dict = (mppc_dict.hist);  
1184    
1185          in_uint8s(s, 6);        /* shareid, pad, streamid */          in_uint8s(s, 6);        /* shareid, pad, streamid */
1186          in_uint16(s, len);          in_uint16(s, len);
# Line 974  process_data_pdu(STREAM s, uint32 * ext_ Line 1191  process_data_pdu(STREAM s, uint32 * ext_
1191    
1192          if (ctype & RDP_MPPC_COMPRESSED)          if (ctype & RDP_MPPC_COMPRESSED)
1193          {          {
1194                    if (len > RDP_MPPC_DICT_SIZE)
1195                            error("error decompressed packet size exceeds max\n");
1196                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1197                          error("error while decompressing packet\n");                          error("error while decompressing packet\n");
1198    
1199                  len -= 18;                  //len -= 18;
   
                 /* this should never happen */  
                 if (len != rlen)  
                         error("decompression error len != rlen\n");  
1200    
1201                  /* allocate memory and copy the uncompressed data into the temporary stream */                  /* allocate memory and copy the uncompressed data into the temporary stream */
1202                  ns->data = xrealloc(ns->data, len);                  ns->data = (uint8 *) xrealloc(ns->data, rlen);
1203    
1204                  memcpy((ns->data), (unsigned char *) (mppc_dict.hist + roff), len);                  memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
1205    
1206                  ns->size = len;                  ns->size = rlen;
1207                  ns->end = (ns->data + ns->size);                  ns->end = (ns->data + ns->size);
1208                  ns->p = ns->data;                  ns->p = ns->data;
1209                  ns->rdp_hdr = ns->p;                  ns->rdp_hdr = ns->p;
# Line 1035  process_data_pdu(STREAM s, uint32 * ext_ Line 1249  process_data_pdu(STREAM s, uint32 * ext_
1249  }  }
1250    
1251  /* Process incoming packets */  /* Process incoming packets */
1252    /* nevers gets out of here till app is done */
1253  void  void
1254  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1255  {  {
1256            while (rdp_loop(deactivated, ext_disc_reason))
1257                    ;
1258    }
1259    
1260    /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1261    BOOL
1262    rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1263    {
1264          uint8 type;          uint8 type;
1265          BOOL disc = False;      /* True when a disconnect PDU was received */          BOOL disc = False;      /* True when a disconnect PDU was received */
1266            BOOL cont = True;
1267          STREAM s;          STREAM s;
1268    
1269          while ((s = rdp_recv(&type)) != NULL)          while (cont)
1270          {          {
1271                    s = rdp_recv(&type);
1272                    if (s == NULL)
1273                            return False;
1274                  switch (type)                  switch (type)
1275                  {                  {
1276                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1277                                  process_demand_active(s);                                  process_demand_active(s);
1278                                  *deactivated = False;                                  *deactivated = False;
1279                                  break;                                  break;
   
1280                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1281                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1282                                  *deactivated = True;                                  *deactivated = True;
1283                                  break;                                  break;
   
1284                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1285                                  disc = process_data_pdu(s, ext_disc_reason);                                  disc = process_data_pdu(s, ext_disc_reason);
1286                                  break;                                  break;
   
1287                          case 0:                          case 0:
1288                                  break;                                  break;
   
1289                          default:                          default:
1290                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1291                  }                  }
   
1292                  if (disc)                  if (disc)
1293                  {                          return False;
1294                          return;                  cont = g_next_packet < s->end;
                 }  
1295          }          }
1296          return;          return True;
1297  }  }
1298    
1299  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.683  
changed lines
  Added in v.858
  ViewVC Help
Powered by ViewVC 1.1.26