/[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 678 by jsorg71, Mon Apr 26 22:31:22 2004 UTC revision 861 by stargo, Sun Mar 13 17:40:51 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 g_mppc_dict;
57    
58  #if WITH_DEBUG  #if WITH_DEBUG
59  static uint32 g_packetno;  static uint32 g_packetno;
60  #endif  #endif
# Line 48  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 123  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;
188                    pout = (char *) s->p;
189            }
190    
191            if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
192            {
193                    iconv_close(iconv_h);
194                    iconv_h = (iconv_t) - 1;
195                    printf("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);
196                    return;
197            }
198    
199    #ifdef B_ENDIAN
200            swab(ss, (char *) s->p, len + 4);
201    #endif
202    
203            s->p += len + 2;
204    
205    #else /*HAVE_ICONV undef */
206          int i = 0, j = 0;          int i = 0, j = 0;
207    
208          len += 2;          len += 2;
# Line 134  rdp_out_unistr(STREAM s, char *string, i Line 214  rdp_out_unistr(STREAM s, char *string, i
214          }          }
215    
216          s->p += len;          s->p += len;
217    #endif
218  }  }
219    
220  /* Input a string in Unicode  /* Input a string in Unicode
# Line 143  rdp_out_unistr(STREAM s, char *string, i Line 224  rdp_out_unistr(STREAM s, char *string, i
224  int  int
225  rdp_in_unistr(STREAM s, char *string, int uni_len)  rdp_in_unistr(STREAM s, char *string, int uni_len)
226  {  {
227    #ifdef HAVE_ICONV
228            size_t ibl = uni_len, obl = uni_len;
229            char *pin, *pout = string;
230            static iconv_t iconv_h = (iconv_t) - 1;
231    #ifdef B_ENDIAN
232            char ss[4096];          // FIXME: global MAX_BUF_SIZE macro need
233    
234            swab((char *) s->p, ss, uni_len);
235            pin = ss;
236    #else
237            pin = s->p;
238    #endif
239    
240            if (iconv_h == (iconv_t) - 1)
241            {
242                    if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)
243                    {
244                            printf("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",
245                                   WINDOWS_CODEPAGE, g_codepage, (int) iconv_h);
246                            return 0;
247                    }
248            }
249    
250            if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
251            {
252                    iconv_close(iconv_h);
253                    iconv_h = (iconv_t) - 1;
254                    printf("rdp_in_unistr: iconv fail, errno %d\n", errno);
255                    return 0;
256            }
257            return pout - string;
258    #else /* HAVE_ICONV undef */
259          int i = 0;          int i = 0;
260    
261          while (i < uni_len / 2)          while (i < uni_len / 2)
# Line 152  rdp_in_unistr(STREAM s, char *string, in Line 265  rdp_in_unistr(STREAM s, char *string, in
265          }          }
266    
267          return i - 1;          return i - 1;
268    #endif
269  }  }
270    
271    
# Line 175  rdp_send_logon_info(uint32 flags, char * Line 289  rdp_send_logon_info(uint32 flags, char *
289          time_t tzone;          time_t tzone;
290    
291  #if 0  #if 0
292          // enable rdp compression          /* enable rdp compression */
293            /* some problems still exist with rdp5 */
294          flags |= RDP_COMPRESSION;          flags |= RDP_COMPRESSION;
295  #endif  #endif
296    
# Line 201  rdp_send_logon_info(uint32 flags, char * Line 316  rdp_send_logon_info(uint32 flags, char *
316          }          }
317          else          else
318          {          {
319    
320                  flags |= RDP_LOGON_BLOB;                  flags |= RDP_LOGON_BLOB;
321                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
322                  packetlen = 4 + /* Unknown uint32 */                  packetlen = 4 + /* Unknown uint32 */
# Line 362  rdp_send_input(uint32 time, uint16 messa Line 478  rdp_send_input(uint32 time, uint16 messa
478          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
479  }  }
480    
481    /* Inform the server on the contents of the persistent bitmap cache */
482    static void
483    rdp_enum_bmpcache2(void)
484    {
485            STREAM s;
486            HASH_KEY keylist[BMPCACHE2_NUM_PSTCELLS];
487            uint32 num_keys, offset, count, flags;
488    
489            offset = 0;
490            num_keys = pstcache_enumerate(2, keylist);
491    
492            while (offset < num_keys)
493            {
494                    count = MIN(num_keys - offset, 169);
495    
496                    s = rdp_init_data(24 + count * sizeof(HASH_KEY));
497    
498                    flags = 0;
499                    if (offset == 0)
500                            flags |= PDU_FLAG_FIRST;
501                    if (num_keys - offset <= 169)
502                            flags |= PDU_FLAG_LAST;
503    
504                    /* header */
505                    out_uint32_le(s, 0);
506                    out_uint16_le(s, count);
507                    out_uint16_le(s, 0);
508                    out_uint16_le(s, 0);
509                    out_uint16_le(s, 0);
510                    out_uint16_le(s, 0);
511                    out_uint16_le(s, num_keys);
512                    out_uint32_le(s, 0);
513                    out_uint32_le(s, flags);
514    
515                    /* list */
516                    out_uint8a(s, keylist[offset], count * sizeof(HASH_KEY));
517    
518                    s_mark_end(s);
519                    rdp_send_data(s, 0x2b);
520    
521                    offset += 169;
522            }
523    }
524    
525  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
526  static void  static void
527  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 432  rdp_out_order_caps(STREAM s) Line 592  rdp_out_order_caps(STREAM s)
592  {  {
593          uint8 order_caps[32];          uint8 order_caps[32];
594    
   
595          memset(order_caps, 0, 32);          memset(order_caps, 0, 32);
596          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
597          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
598          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
599          order_caps[3] = (g_bitmap_cache ? 1 : 0); /* memblt */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
600            order_caps[4] = 0;      /* triblt */
601          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
602          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
603          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
604          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */          order_caps[11] = (g_desktop_save ? 1 : 0);      /* desksave */
605          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
606          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
607            order_caps[20] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon */
608            order_caps[21] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon2 */
609          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
610            order_caps[25] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse */
611            order_caps[26] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse2 */
612          order_caps[27] = 1;     /* text2 */          order_caps[27] = 1;     /* text2 */
613          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
614          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
# Line 482  rdp_out_bmpcache_caps(STREAM s) Line 646  rdp_out_bmpcache_caps(STREAM s)
646          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
647  }  }
648    
649    /* Output bitmap cache v2 capability set */
650    static void
651    rdp_out_bmpcache2_caps(STREAM s)
652    {
653            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
654            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
655    
656            out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
657    
658            out_uint16_le(s, 0x0300);       /* flags? number of caches? */
659    
660            out_uint32_le(s, BMPCACHE2_C0_CELLS);
661            out_uint32_le(s, BMPCACHE2_C1_CELLS);
662            if (pstcache_init(2))
663            {
664                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
665            }
666            else
667            {
668                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
669            }
670            out_uint8s(s, 20);      /* other bitmap caches not used */
671    }
672    
673  /* Output control capability set */  /* Output control capability set */
674  static void  static void
675  rdp_out_control_caps(STREAM s)  rdp_out_control_caps(STREAM s)
# Line 541  rdp_out_colcache_caps(STREAM s) Line 729  rdp_out_colcache_caps(STREAM s)
729          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
730  }  }
731    
732  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
733          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
734          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
735          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
736          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
738          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
740          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
742          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
743          0x0C, 0x00, 0x08, 0x00, 0x01,          0x00, 0x00, 0x00, 0x00
744          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,  };
745          0x10, 0x00, 0x34, 0x00, 0xFE,  
746          0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
747          0xFE, 0x00, 0x08, 0x00, 0xFE,  
748          0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,  static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
749          0xFE, 0x00, 0x80, 0x00, 0xFE,  
750          0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,  static uint8 caps_0x10[] = {
751          0x02, 0x00, 0x00, 0x00          0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
752            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
753            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
754            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
755            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
756            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
757  };  };
758    
759  /* Output unknown capability sets (number 13, 12, 14 and 16) */  /* Output unknown capability sets */
760  static void  static void
761  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 * caps)
762  {  {
763          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
764          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
765    
766          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
767  }  }
768    
769  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 584  rdp_send_confirm_active(void) Line 777  rdp_send_confirm_active(void)
777                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
778                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
779                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
780                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
781                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */  +
782                    4 /* w2k fix, why? */ ;
783    
784          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
785    
# Line 604  rdp_send_confirm_active(void) Line 799  rdp_send_confirm_active(void)
799          rdp_out_general_caps(s);          rdp_out_general_caps(s);
800          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
801          rdp_out_order_caps(s);          rdp_out_order_caps(s);
802          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
803          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
804          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
805          rdp_out_control_caps(s);          rdp_out_control_caps(s);
806          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
807          rdp_out_share_caps(s);          rdp_out_share_caps(s);
808          rdp_out_unknown_caps(s);  
809            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
810            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
811            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
812            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
813    
814          s_mark_end(s);          s_mark_end(s);
815          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 647  rdp_process_bitmap_caps(STREAM s) Line 846  rdp_process_bitmap_caps(STREAM s)
846           * 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
847           * example when shadowing another session).           * example when shadowing another session).
848           */           */
849          g_server_bpp = bpp;          if (g_server_bpp != bpp)
850          g_width = width;          {
851          g_height = height;                  warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);
852                    g_server_bpp = bpp;
853          ui_resize_window();          }
854            if (g_width != width || g_height != height)
855            {
856                    warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
857                            width, height);
858                    g_width = width;
859                    g_height = height;
860                    ui_resize_window();
861            }
862  }  }
863    
864  /* Respond to a demand active PDU */  /* Process server capabilities */
865  static void  void
866  process_demand_active(STREAM s)  rdp_process_server_caps(STREAM s, uint16 length)
867  {  {
868          int n;          int n;
869          uint8 type, *next;          uint8 *next, *start;
870          uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;          uint16 ncapsets, capset_type, capset_length;
871    
872          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);  
873    
874          in_uint16_le(s, num_capsets);          in_uint16_le(s, ncapsets);
875          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
876    
877          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++)  
878          {          {
879                    if (s->p > start + length)
880                            return;
881    
882                  in_uint16_le(s, capset_type);                  in_uint16_le(s, capset_type);
883                  in_uint16_le(s, capset_length);                  in_uint16_le(s, capset_length);
884    
# Line 692  process_demand_active(STREAM s) Line 897  process_demand_active(STREAM s)
897    
898                  s->p = next;                  s->p = next;
899          }          }
900    }
901    
902    /* Respond to a demand active PDU */
903    static void
904    process_demand_active(STREAM s)
905    {
906            uint8 type;
907            uint16 len_src_descriptor, len_combined_caps;
908    
909            in_uint32_le(s, g_rdp_shareid);
910            in_uint16_le(s, len_src_descriptor);
911            in_uint16_le(s, len_combined_caps);
912            in_uint8s(s, len_src_descriptor);
913    
914            DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
915            rdp_process_server_caps(s, len_combined_caps);
916    
917          rdp_send_confirm_active();          rdp_send_confirm_active();
918          rdp_send_synchronise();          rdp_send_synchronise();
# Line 704  process_demand_active(STREAM s) Line 925  process_demand_active(STREAM s)
925    
926          if (g_use_rdp5)          if (g_use_rdp5)
927          {          {
928                    rdp_enum_bmpcache2();
929                  rdp_send_fonts(3);                  rdp_send_fonts(3);
930          }          }
931          else          else
# Line 912  process_update_pdu(STREAM s) Line 1134  process_update_pdu(STREAM s)
1134    
1135          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
1136    
1137            ui_begin_update();
1138          switch (update_type)          switch (update_type)
1139          {          {
1140                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 935  process_update_pdu(STREAM s) Line 1158  process_update_pdu(STREAM s)
1158                  default:                  default:
1159                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
1160          }          }
1161            ui_end_update();
1162  }  }
1163    
1164  /* Process a disconnect PDU */  /* Process a disconnect PDU */
# Line 954  process_data_pdu(STREAM s, uint32 * ext_ Line 1177  process_data_pdu(STREAM s, uint32 * ext_
1177          uint8 data_pdu_type;          uint8 data_pdu_type;
1178          uint8 ctype;          uint8 ctype;
1179          uint16 clen;          uint16 clen;
1180          int len;          uint32 len;
1181  #if 0  
1182          int roff, rlen, ret;          uint32 roff, rlen;
1183          static struct stream ns;  
1184          static signed char *dict = 0;          struct stream *ns = &(g_mppc_dict.ns);
 #endif  
1185    
1186          in_uint8s(s, 6);        /* shareid, pad, streamid */          in_uint8s(s, 6);        /* shareid, pad, streamid */
1187          in_uint16(s, len);          in_uint16(s, len);
# Line 968  process_data_pdu(STREAM s, uint32 * ext_ Line 1190  process_data_pdu(STREAM s, uint32 * ext_
1190          in_uint16(s, clen);          in_uint16(s, clen);
1191          clen -= 18;          clen -= 18;
1192    
1193  #if 0          if (ctype & RDP_MPPC_COMPRESSED)
         if (ctype & 0x20)  
1194          {          {
1195                  if (!dict)                  if (len > RDP_MPPC_DICT_SIZE)
1196                  {                          error("error decompressed packet size exceeds max\n");
1197                          dict = (signed char *) malloc(8200 * sizeof(signed char));                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1198                          dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));                          error("error while decompressing packet\n");
                 }  
1199    
1200                  ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);                  //len -= 18;
1201    
1202                  len -= 18;                  /* allocate memory and copy the uncompressed data into the temporary stream */
1203                    ns->data = (uint8 *) xrealloc(ns->data, rlen);
1204    
1205                  ns.data = xrealloc(ns.data, len);                  memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
1206    
1207                  ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);                  ns->size = rlen;
1208                    ns->end = (ns->data + ns->size);
1209                    ns->p = ns->data;
1210                    ns->rdp_hdr = ns->p;
1211    
1212                  ns.size = len;                  s = ns;
                 ns.end = ns.data + ns.size;  
                 ns.p = ns.data;  
                 ns.rdp_hdr = ns.p;  
   
                 s = &ns;  
1213          }          }
 #endif  
1214    
1215          switch (data_pdu_type)          switch (data_pdu_type)
1216          {          {
# Line 1032  process_data_pdu(STREAM s, uint32 * ext_ Line 1250  process_data_pdu(STREAM s, uint32 * ext_
1250  }  }
1251    
1252  /* Process incoming packets */  /* Process incoming packets */
1253    /* nevers gets out of here till app is done */
1254  void  void
1255  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1256  {  {
1257            while (rdp_loop(deactivated, ext_disc_reason))
1258                    ;
1259    }
1260    
1261    /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1262    BOOL
1263    rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1264    {
1265          uint8 type;          uint8 type;
1266          BOOL disc = False;      /* True when a disconnect PDU was received */          BOOL disc = False;      /* True when a disconnect PDU was received */
1267            BOOL cont = True;
1268          STREAM s;          STREAM s;
1269    
1270          while ((s = rdp_recv(&type)) != NULL)          while (cont)
1271          {          {
1272                    s = rdp_recv(&type);
1273                    if (s == NULL)
1274                            return False;
1275                  switch (type)                  switch (type)
1276                  {                  {
1277                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1278                                  process_demand_active(s);                                  process_demand_active(s);
1279                                  *deactivated = False;                                  *deactivated = False;
1280                                  break;                                  break;
   
1281                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1282                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1283                                  *deactivated = True;                                  *deactivated = True;
1284                                  break;                                  break;
   
1285                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1286                                  disc = process_data_pdu(s, ext_disc_reason);                                  disc = process_data_pdu(s, ext_disc_reason);
1287                                  break;                                  break;
   
1288                          case 0:                          case 0:
1289                                  break;                                  break;
   
1290                          default:                          default:
1291                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1292                  }                  }
   
1293                  if (disc)                  if (disc)
1294                  {                          return False;
1295                          return;                  cont = g_next_packet < s->end;
                 }  
1296          }          }
1297          return;          return True;
1298  }  }
1299    
1300  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.678  
changed lines
  Added in v.861
  ViewVC Help
Powered by ViewVC 1.1.26