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