/[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 711 by jsorg71, Tue Jun 15 22:45:12 2004 UTC revision 866 by stargo, Sat Mar 19 15:30:14 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;
# Line 44  extern RDPCOMP g_mppc_dict; Line 59  extern RDPCOMP g_mppc_dict;
59  static uint32 g_packetno;  static uint32 g_packetno;
60  #endif  #endif
61    
62    #ifdef HAVE_ICONV
63    static BOOL g_iconv_works = True;
64    #endif
65    
66  /* Receive an RDP packet */  /* Receive an RDP packet */
67  static STREAM  static STREAM
68  rdp_recv(uint8 * type)  rdp_recv(uint8 * type)
69  {  {
70          static STREAM rdp_s;          static STREAM rdp_s;
71          uint16 length, pdu_type;          uint16 length, pdu_type;
72            uint8 rdpver;
73    
74          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
75          {          {
76                  rdp_s = sec_recv();                  rdp_s = sec_recv(&rdpver);
77                  if (rdp_s == NULL)                  if (rdp_s == NULL)
78                          return NULL;                          return NULL;
79                    if (rdpver == 0xff)
80                    {
81                            g_next_packet = rdp_s->end;
82                            *type = 0;
83                            return rdp_s;
84                    }
85                    else if (rdpver != 3)
86                    {
87                            /* rdp5_process should move g_next_packet ok */
88                            rdp5_process(rdp_s);
89                            *type = 0;
90                            return rdp_s;
91                    }
92    
93                  g_next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
94          }          }
# Line 125  rdp_send_data(STREAM s, uint8 data_pdu_t Line 158  rdp_send_data(STREAM s, uint8 data_pdu_t
158  void  void
159  rdp_out_unistr(STREAM s, char *string, int len)  rdp_out_unistr(STREAM s, char *string, int len)
160  {  {
161          int i = 0, j = 0;  #ifdef HAVE_ICONV
162            size_t ibl = strlen(string), obl = len + 2;
163            static iconv_t iconv_h = (iconv_t) - 1;
164            char *pin = string, *pout = (char *)s->p;
165    
166          len += 2;          memset(pout, 0, len + 4);
167    
168          while (i < len)          if (g_iconv_works)
169          {          {
170                  s->p[i++] = string[j++];                  if (iconv_h == (iconv_t) - 1)
171                  s->p[i++] = 0;                  {
172                            size_t i = 1, o = 4;
173                            if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t) - 1)
174                            {
175                                    warning("rdp_out_unistr: iconv_open[%s -> %s] fail %d\n",
176                                            g_codepage, WINDOWS_CODEPAGE, (int) iconv_h);
177    
178                                    g_iconv_works = False;
179                                    rdp_out_unistr(s, string, len);
180                                    return;
181                            }
182                            if (iconv(iconv_h, (ICONV_CONST char **) &pin, &i, &pout, &o) ==
183                                (size_t) - 1)
184                            {
185                                    iconv_close(iconv_h);
186                                    iconv_h = (iconv_t) - 1;
187                                    warning("rdp_out_unistr: iconv(1) fail, errno %d\n", errno);
188    
189                                    g_iconv_works = False;
190                                    rdp_out_unistr(s, string, len);
191                                    return;
192                            }
193                            pin = string;
194                            pout = (char *) s->p;
195                    }
196    
197                    if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
198                    {
199                            iconv_close(iconv_h);
200                            iconv_h = (iconv_t) - 1;
201                            warning("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);
202    
203                            g_iconv_works = False;
204                            rdp_out_unistr(s, string, len);
205                            return;
206                    }
207    
208                    s->p += len + 2;
209    
210          }          }
211            else
212    #endif
213            {
214                    int i = 0, j = 0;
215    
216                    len += 2;
217    
218                    while (i < len)
219                    {
220                            s->p[i++] = string[j++];
221                            s->p[i++] = 0;
222                    }
223    
224          s->p += len;                  s->p += len;
225            }
226  }  }
227    
228  /* Input a string in Unicode  /* Input a string in Unicode
# Line 145  rdp_out_unistr(STREAM s, char *string, i Line 232  rdp_out_unistr(STREAM s, char *string, i
232  int  int
233  rdp_in_unistr(STREAM s, char *string, int uni_len)  rdp_in_unistr(STREAM s, char *string, int uni_len)
234  {  {
235          int i = 0;  #ifdef HAVE_ICONV
236            size_t ibl = uni_len, obl = uni_len;
237            char *pin = (char *)s->p, *pout = string;
238            static iconv_t iconv_h = (iconv_t) - 1;
239    
240          while (i < uni_len / 2)          if (g_iconv_works)
241          {          {
242                  in_uint8a(s, &string[i++], 1);                  if (iconv_h == (iconv_t) - 1)
243                  in_uint8s(s, 1);                  {
244                            if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)
245                            {
246                                    warning("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",
247                                            WINDOWS_CODEPAGE, g_codepage, (int) iconv_h);
248    
249                                    g_iconv_works = False;
250                                    return rdp_in_unistr(s, string, uni_len);
251                            }
252                    }
253    
254                    if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
255                    {
256                            iconv_close(iconv_h);
257                            iconv_h = (iconv_t) - 1;
258                            warning("rdp_in_unistr: iconv fail, errno %d\n", errno);
259    
260                            g_iconv_works = False;
261                            return rdp_in_unistr(s, string, uni_len);
262                    }
263                    return pout - string;
264          }          }
265            else
266    #endif
267            {
268                    int i = 0;
269    
270          return i - 1;                  while (i < uni_len / 2)
271                    {
272                            in_uint8a(s, &string[i++], 1);
273                            in_uint8s(s, 1);
274                    }
275    
276                    return i - 1;
277            }
278  }  }
279    
280    
# Line 366  rdp_send_input(uint32 time, uint16 messa Line 487  rdp_send_input(uint32 time, uint16 messa
487          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
488  }  }
489    
490    /* Inform the server on the contents of the persistent bitmap cache */
491    static void
492    rdp_enum_bmpcache2(void)
493    {
494            STREAM s;
495            HASH_KEY keylist[BMPCACHE2_NUM_PSTCELLS];
496            uint32 num_keys, offset, count, flags;
497    
498            offset = 0;
499            num_keys = pstcache_enumerate(2, keylist);
500    
501            while (offset < num_keys)
502            {
503                    count = MIN(num_keys - offset, 169);
504    
505                    s = rdp_init_data(24 + count * sizeof(HASH_KEY));
506    
507                    flags = 0;
508                    if (offset == 0)
509                            flags |= PDU_FLAG_FIRST;
510                    if (num_keys - offset <= 169)
511                            flags |= PDU_FLAG_LAST;
512    
513                    /* header */
514                    out_uint32_le(s, 0);
515                    out_uint16_le(s, count);
516                    out_uint16_le(s, 0);
517                    out_uint16_le(s, 0);
518                    out_uint16_le(s, 0);
519                    out_uint16_le(s, 0);
520                    out_uint16_le(s, num_keys);
521                    out_uint32_le(s, 0);
522                    out_uint32_le(s, flags);
523    
524                    /* list */
525                    out_uint8a(s, keylist[offset], count * sizeof(HASH_KEY));
526    
527                    s_mark_end(s);
528                    rdp_send_data(s, 0x2b);
529    
530                    offset += 169;
531            }
532    }
533    
534  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
535  static void  static void
536  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 436  rdp_out_order_caps(STREAM s) Line 601  rdp_out_order_caps(STREAM s)
601  {  {
602          uint8 order_caps[32];          uint8 order_caps[32];
603    
   
604          memset(order_caps, 0, 32);          memset(order_caps, 0, 32);
605          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
606          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
607          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
608          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
609            order_caps[4] = 0;      /* triblt */
610          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
611          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
612          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
613          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */          order_caps[11] = (g_desktop_save ? 1 : 0);      /* desksave */
614          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
615          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
616            order_caps[20] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon */
617            order_caps[21] = (g_polygon_ellipse_orders ? 1 : 0);    /* polygon2 */
618          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
619            order_caps[25] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse */
620            order_caps[26] = (g_polygon_ellipse_orders ? 1 : 0);    /* ellipse2 */
621          order_caps[27] = 1;     /* text2 */          order_caps[27] = 1;     /* text2 */
622          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
623          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
# Line 486  rdp_out_bmpcache_caps(STREAM s) Line 655  rdp_out_bmpcache_caps(STREAM s)
655          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
656  }  }
657    
658    /* Output bitmap cache v2 capability set */
659    static void
660    rdp_out_bmpcache2_caps(STREAM s)
661    {
662            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
663            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
664    
665            out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
666    
667            out_uint16_le(s, 0x0300);       /* flags? number of caches? */
668    
669            out_uint32_le(s, BMPCACHE2_C0_CELLS);
670            out_uint32_le(s, BMPCACHE2_C1_CELLS);
671            if (pstcache_init(2))
672            {
673                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
674            }
675            else
676            {
677                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
678            }
679            out_uint8s(s, 20);      /* other bitmap caches not used */
680    }
681    
682  /* Output control capability set */  /* Output control capability set */
683  static void  static void
684  rdp_out_control_caps(STREAM s)  rdp_out_control_caps(STREAM s)
# Line 545  rdp_out_colcache_caps(STREAM s) Line 738  rdp_out_colcache_caps(STREAM s)
738          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
739  }  }
740    
741  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
742          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
743          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
744          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
745          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
746          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
747          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
748          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
749          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
750          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
751          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
752          0x0C, 0x00, 0x08, 0x00, 0x01,          0x00, 0x00, 0x00, 0x00
753          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,  };
754          0x10, 0x00, 0x34, 0x00, 0xFE,  
755          0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
756          0xFE, 0x00, 0x08, 0x00, 0xFE,  
757          0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,  static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
758          0xFE, 0x00, 0x80, 0x00, 0xFE,  
759          0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,  static uint8 caps_0x10[] = {
760          0x02, 0x00, 0x00, 0x00          0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
761            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
762            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
763            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
764            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
765            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
766  };  };
767    
768  /* Output unknown capability sets (number 13, 12, 14 and 16) */  /* Output unknown capability sets */
769  static void  static void
770  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 * caps)
771  {  {
772          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
773          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
774    
775          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
776  }  }
777    
778  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 588  rdp_send_confirm_active(void) Line 786  rdp_send_confirm_active(void)
786                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
787                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
788                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
789                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
790                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */  +
791                    4 /* w2k fix, why? */ ;
792    
793          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
794    
# Line 608  rdp_send_confirm_active(void) Line 808  rdp_send_confirm_active(void)
808          rdp_out_general_caps(s);          rdp_out_general_caps(s);
809          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
810          rdp_out_order_caps(s);          rdp_out_order_caps(s);
811          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
812          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
813          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
814          rdp_out_control_caps(s);          rdp_out_control_caps(s);
815          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
816          rdp_out_share_caps(s);          rdp_out_share_caps(s);
817          rdp_out_unknown_caps(s);  
818            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
819            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
820            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
821            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
822    
823          s_mark_end(s);          s_mark_end(s);
824          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 659  rdp_process_bitmap_caps(STREAM s) Line 863  rdp_process_bitmap_caps(STREAM s)
863          if (g_width != width || g_height != height)          if (g_width != width || g_height != height)
864          {          {
865                  warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,                  warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
866                                  width, height);                          width, height);
867                  g_width = width;                  g_width = width;
868                  g_height = height;                  g_height = height;
869                  ui_resize_window();                  ui_resize_window();
870          }          }
871  }  }
872    
873  /* Respond to a demand active PDU */  /* Process server capabilities */
874  static void  void
875  process_demand_active(STREAM s)  rdp_process_server_caps(STREAM s, uint16 length)
876  {  {
877          int n;          int n;
878          uint8 type, *next;          uint8 *next, *start;
879          uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;          uint16 ncapsets, capset_type, capset_length;
880    
881          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);  
882    
883          in_uint16_le(s, num_capsets);          in_uint16_le(s, ncapsets);
884          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
885    
886          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++)  
887          {          {
888                    if (s->p > start + length)
889                            return;
890    
891                  in_uint16_le(s, capset_type);                  in_uint16_le(s, capset_type);
892                  in_uint16_le(s, capset_length);                  in_uint16_le(s, capset_length);
893    
# Line 704  process_demand_active(STREAM s) Line 906  process_demand_active(STREAM s)
906    
907                  s->p = next;                  s->p = next;
908          }          }
909    }
910    
911    /* Respond to a demand active PDU */
912    static void
913    process_demand_active(STREAM s)
914    {
915            uint8 type;
916            uint16 len_src_descriptor, len_combined_caps;
917    
918            in_uint32_le(s, g_rdp_shareid);
919            in_uint16_le(s, len_src_descriptor);
920            in_uint16_le(s, len_combined_caps);
921            in_uint8s(s, len_src_descriptor);
922    
923            DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
924            rdp_process_server_caps(s, len_combined_caps);
925    
926          rdp_send_confirm_active();          rdp_send_confirm_active();
927          rdp_send_synchronise();          rdp_send_synchronise();
# Line 716  process_demand_active(STREAM s) Line 934  process_demand_active(STREAM s)
934    
935          if (g_use_rdp5)          if (g_use_rdp5)
936          {          {
937                    rdp_enum_bmpcache2();
938                  rdp_send_fonts(3);                  rdp_send_fonts(3);
939          }          }
940          else          else
# Line 924  process_update_pdu(STREAM s) Line 1143  process_update_pdu(STREAM s)
1143    
1144          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
1145    
1146            ui_begin_update();
1147          switch (update_type)          switch (update_type)
1148          {          {
1149                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 947  process_update_pdu(STREAM s) Line 1167  process_update_pdu(STREAM s)
1167                  default:                  default:
1168                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
1169          }          }
1170            ui_end_update();
1171  }  }
1172    
1173  /* Process a disconnect PDU */  /* Process a disconnect PDU */
# Line 981  process_data_pdu(STREAM s, uint32 * ext_ Line 1201  process_data_pdu(STREAM s, uint32 * ext_
1201    
1202          if (ctype & RDP_MPPC_COMPRESSED)          if (ctype & RDP_MPPC_COMPRESSED)
1203          {          {
1204                    if (len > RDP_MPPC_DICT_SIZE)
1205                            error("error decompressed packet size exceeds max\n");
1206                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1207                          error("error while decompressing packet\n");                          error("error while decompressing packet\n");
1208    
1209                  //len -= 18;                  /* len -= 18; */
1210    
1211                  /* allocate memory and copy the uncompressed data into the temporary stream */                  /* allocate memory and copy the uncompressed data into the temporary stream */
1212                  ns->data = (uint8 *) xrealloc(ns->data, rlen);                  ns->data = (uint8 *) xrealloc(ns->data, rlen);
# Line 1038  process_data_pdu(STREAM s, uint32 * ext_ Line 1259  process_data_pdu(STREAM s, uint32 * ext_
1259  }  }
1260    
1261  /* Process incoming packets */  /* Process incoming packets */
1262    /* nevers gets out of here till app is done */
1263  void  void
1264  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1265  {  {
1266            while (rdp_loop(deactivated, ext_disc_reason))
1267                    ;
1268    }
1269    
1270    /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1271    BOOL
1272    rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1273    {
1274          uint8 type;          uint8 type;
1275          BOOL disc = False;      /* True when a disconnect PDU was received */          BOOL disc = False;      /* True when a disconnect PDU was received */
1276            BOOL cont = True;
1277          STREAM s;          STREAM s;
1278    
1279          while ((s = rdp_recv(&type)) != NULL)          while (cont)
1280          {          {
1281                    s = rdp_recv(&type);
1282                    if (s == NULL)
1283                            return False;
1284                  switch (type)                  switch (type)
1285                  {                  {
1286                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1287                                  process_demand_active(s);                                  process_demand_active(s);
1288                                  *deactivated = False;                                  *deactivated = False;
1289                                  break;                                  break;
   
1290                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1291                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1292                                  *deactivated = True;                                  *deactivated = True;
1293                                  break;                                  break;
   
1294                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1295                                  disc = process_data_pdu(s, ext_disc_reason);                                  disc = process_data_pdu(s, ext_disc_reason);
1296                                  break;                                  break;
   
1297                          case 0:                          case 0:
1298                                  break;                                  break;
   
1299                          default:                          default:
1300                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1301                  }                  }
   
1302                  if (disc)                  if (disc)
1303                  {                          return False;
1304                          return;                  cont = g_next_packet < s->end;
                 }  
1305          }          }
1306          return;          return True;
1307  }  }
1308    
1309  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.711  
changed lines
  Added in v.866
  ViewVC Help
Powered by ViewVC 1.1.26