/[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 365 by matthewc, Wed Apr 16 08:19:15 2003 UTC revision 678 by jsorg71, Mon Apr 26 22:31:22 2004 UTC
# Line 2  Line 2 
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-2002
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
8     the Free Software Foundation; either version 2 of the License, or     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.     (at your option) any later version.
10      
11     This program is distributed in the hope that it will be useful,     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.     GNU General Public License for more details.
15      
16     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */  */
20    
21    #include <time.h>
22  #include "rdesktop.h"  #include "rdesktop.h"
23    
24  extern uint16 mcs_userid;  extern uint16 g_mcs_userid;
25  extern char username[16];  extern char g_username[16];
26  extern BOOL bitmap_compression;  extern BOOL g_bitmap_compression;
27  extern BOOL orders;  extern BOOL g_orders;
28  extern BOOL encryption;  extern BOOL g_encryption;
29  extern BOOL desktop_save;  extern BOOL g_desktop_save;
30  extern BOOL use_rdp5;  extern BOOL g_use_rdp5;
31  extern uint16 server_rdp_version;  extern uint16 g_server_rdp_version;
32    extern uint32 g_rdp5_performanceflags;
33    extern int g_server_bpp;
34    extern int g_width;
35    extern int g_height;
36    extern BOOL g_bitmap_cache;
37    
38  uint8 *next_packet;  uint8 *g_next_packet;
39  uint32 rdp_shareid;  uint32 g_rdp_shareid;
40    
41  #if WITH_DEBUG  #if WITH_DEBUG
42  static uint32 packetno;  static uint32 g_packetno;
43  #endif  #endif
44    
45  /* Receive an RDP packet */  /* Receive an RDP packet */
# Line 43  rdp_recv(uint8 * type) Line 49  rdp_recv(uint8 * type)
49          static STREAM rdp_s;          static STREAM rdp_s;
50          uint16 length, pdu_type;          uint16 length, pdu_type;
51    
52          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
53          {          {
54                  rdp_s = sec_recv();                  rdp_s = sec_recv();
55                  if (rdp_s == NULL)                  if (rdp_s == NULL)
56                          return NULL;                          return NULL;
57    
58                  next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
59          }          }
60          else          else
61          {          {
62                  rdp_s->p = next_packet;                  rdp_s->p = g_next_packet;
63          }          }
64    
65          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
66          /* 32k packets are really 8, keepalive fix */          /* 32k packets are really 8, keepalive fix */
67          if (length == 0x8000)          if (length == 0x8000)
68          {          {
69                  next_packet += 8;                  g_next_packet += 8;
70                  *type = 0;                  *type = 0;
71                  return rdp_s;                  return rdp_s;
72          }          }
# Line 69  rdp_recv(uint8 * type) Line 75  rdp_recv(uint8 * type)
75          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
76    
77  #if WITH_DEBUG  #if WITH_DEBUG
78          DEBUG(("RDP packet #%d, (type %x)\n", ++packetno, *type));          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
79          //      hexdump(next_packet, length);          hexdump(g_next_packet, length);
80  #endif /*  */  #endif /*  */
81    
82          next_packet += length;          g_next_packet += length;
83          return rdp_s;          return rdp_s;
84  }  }
85    
# Line 83  rdp_init_data(int maxlen) Line 89  rdp_init_data(int maxlen)
89  {  {
90          STREAM s;          STREAM s;
91    
92          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
93          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
94    
95          return s;          return s;
# Line 100  rdp_send_data(STREAM s, uint8 data_pdu_t Line 106  rdp_send_data(STREAM s, uint8 data_pdu_t
106    
107          out_uint16_le(s, length);          out_uint16_le(s, length);
108          out_uint16_le(s, (RDP_PDU_DATA | 0x10));          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
109          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
110    
111          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
112          out_uint8(s, 0);        /* pad */          out_uint8(s, 0);        /* pad */
113          out_uint8(s, 1);        /* streamid */          out_uint8(s, 1);        /* streamid */
114          out_uint16_le(s, (length - 14));          out_uint16_le(s, (length - 14));
# Line 110  rdp_send_data(STREAM s, uint8 data_pdu_t Line 116  rdp_send_data(STREAM s, uint8 data_pdu_t
116          out_uint8(s, 0);        /* compress_type */          out_uint8(s, 0);        /* compress_type */
117          out_uint16(s, 0);       /* compress_len */          out_uint16(s, 0);       /* compress_len */
118    
119          sec_send(s, encryption ? SEC_ENCRYPT : 0);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
120  }  }
121    
122  /* Output a string in Unicode */  /* Output a string in Unicode */
# Line 130  rdp_out_unistr(STREAM s, char *string, i Line 136  rdp_out_unistr(STREAM s, char *string, i
136          s->p += len;          s->p += len;
137  }  }
138    
139    /* Input a string in Unicode
140     *
141     * Returns str_len of string
142     */
143    int
144    rdp_in_unistr(STREAM s, char *string, int uni_len)
145    {
146            int i = 0;
147    
148            while (i < uni_len / 2)
149            {
150                    in_uint8a(s, &string[i++], 1);
151                    in_uint8s(s, 1);
152            }
153    
154            return i - 1;
155    }
156    
157    
158  /* Parse a logon info packet */  /* Parse a logon info packet */
159  static void  static void
160  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
161                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
162  {  {
163            char *ipaddr = tcp_get_address();
164          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
165          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
166          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
167          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
168          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
169          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;          int len_ip = 2 * strlen(ipaddr);
170            int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
171            int packetlen = 0;
172            uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
173          STREAM s;          STREAM s;
174            time_t t = time(NULL);
175            time_t tzone;
176    
177    #if 0
178            // enable rdp compression
179            flags |= RDP_COMPRESSION;
180    #endif
181    
182          if (1 == server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
183          {          {
184                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
185    
# Line 165  rdp_send_logon_info(uint32 flags, char * Line 201  rdp_send_logon_info(uint32 flags, char *
201          }          }
202          else          else
203          {          {
204                    flags |= RDP_LOGON_BLOB;
205                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
206                  s = sec_init(sec_flags, 12 + (flags & RDP_LOGON_AUTO ? 2 : 0) + 6 + (flags & RDP_LOGON_AUTO ? len_password : 0) + len_domain + len_user + 4 + len_program + len_directory + 30 + 2 + 60 + 32 + 20 + 32 + 20);   /* Phew! */                  packetlen = 4 + /* Unknown uint32 */
207                            4 +     /* flags */
208                            2 +     /* len_domain */
209                            2 +     /* len_user */
210                            (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
211                            (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
212                            2 +     /* len_program */
213                            2 +     /* len_directory */
214                            (0 < len_domain ? len_domain : 2) +     /* domain */
215                            len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
216                            (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
217                            (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
218                            2 +     /* Client ip length */
219                            len_ip +        /* Client ip */
220                            2 +     /* DLL string length */
221                            len_dll +       /* DLL string */
222                            2 +     /* Unknown */
223                            2 +     /* Unknown */
224                            64 +    /* Time zone #0 */
225                            2 +     /* Unknown */
226                            64 +    /* Time zone #1 */
227                            32;     /* Unknown */
228    
229                  out_uint32(s, 0);                  s = sec_init(sec_flags, packetlen);
230                    DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
231    
232                    out_uint32(s, 0);       /* Unknown */
233                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
234                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
235                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
236                  if (flags & RDP_LOGON_AUTO)                  if (flags & RDP_LOGON_AUTO)
237                  {                  {
238                          out_uint16_le(s, len_password);                          out_uint16_le(s, len_password);
239    
240                    }
241                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
242                    {
243                            out_uint16_le(s, 0);
244                  }                  }
                 out_uint16(s, 0);       /* Seems to be length of a 512 byte blob with  
                                            completely unknown data, but hopefully we'll do  
                                            with a 0 length block as well */  
245                  out_uint16_le(s, len_program);                  out_uint16_le(s, len_program);
246                  out_uint16_le(s, len_directory);                  out_uint16_le(s, len_directory);
247                    if (0 < len_domain)
248                            rdp_out_unistr(s, domain, len_domain);
249                    else
250                            out_uint16_le(s, 0);
251                    rdp_out_unistr(s, user, len_user);
252                  if (flags & RDP_LOGON_AUTO)                  if (flags & RDP_LOGON_AUTO)
253                  {                  {
254                          rdp_out_unistr(s, password, len_password);                          rdp_out_unistr(s, password, len_password);
255                  }                  }
256                  rdp_out_unistr(s, domain, len_domain);                  if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
257                  rdp_out_unistr(s, user, len_user);                  {
258                  out_uint16(s, 0);                          out_uint16_le(s, 0);
259                  out_uint16(s, 0);                  }
260                  if (0 < len_program)                  if (0 < len_program)
261                    {
262                          rdp_out_unistr(s, program, len_program);                          rdp_out_unistr(s, program, len_program);
263    
264                    }
265                    else
266                    {
267                            out_uint16_le(s, 0);
268                    }
269                  if (0 < len_directory)                  if (0 < len_directory)
270                    {
271                          rdp_out_unistr(s, directory, len_directory);                          rdp_out_unistr(s, directory, len_directory);
272                  out_uint8s(s, 30);      /* Some kind of client data - let's see if the server                  }
273                                             handles zeros well.. */                  else
274                  out_uint16_le(s, 60);                  {
275                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", 58);                          out_uint16_le(s, 0);
276                  out_uint32_be(s, 0x88ffffff);                  }
277                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid") - 2);                  out_uint16_le(s, 2);
278                  out_uint8s(s, 30 - 2 * strlen("GTP, normaltid"));                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
279                    rdp_out_unistr(s, ipaddr, len_ip);
280                    out_uint16_le(s, len_dll + 2);
281                    rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
282    
283                    tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
284                    out_uint32_le(s, tzone);
285    
286                    rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
287                    out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
288    
289                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
290                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
291                  out_uint32_le(s, 2);                  out_uint32_le(s, 3);
292                  out_uint32(s, 0);                  out_uint32_le(s, 0);
293                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0);
                 out_uint32_le(s, 0xfffffffe);  
                 out_uint32_le(s, 0x0f);  
                 out_uint32(s, 0);  
294    
295                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid") - 1);                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid"));
296                  out_uint8s(s, 30 - 2 * strlen("GTP, sommartid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, sommartid"));
297    
298                  out_uint32_le(s, 0x030000);                  out_uint32_le(s, 0x30000);
299                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
300                  out_uint32_le(s, 2);                  out_uint32_le(s, 2);
301                  out_uint32(s, 0);                  out_uint32(s, 0);
302                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
303                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
304                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
305                  out_uint32(s, 0);                  out_uint32(s, 0);
306    
307    
308          }          }
309          s_mark_end(s);          s_mark_end(s);
310          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 288  rdp_send_fonts(uint16 seq) Line 371  rdp_send_fonts(uint16 seq)
371          s = rdp_init_data(8);          s = rdp_init_data(8);
372    
373          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
374          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
375          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
376          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
377    
# Line 308  rdp_out_general_caps(STREAM s) Line 391  rdp_out_general_caps(STREAM s)
391          out_uint16_le(s, 0x200);        /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
392          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
393          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
394          out_uint16_le(s, use_rdp5 ? 0x40d : 0);          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
395          /* Pad, according to T.128. 0x40d seems to          /* Pad, according to T.128. 0x40d seems to
396             trigger             trigger
397             the server to start sending RDP5 packets.             the server to start sending RDP5 packets.
# Line 329  rdp_out_bitmap_caps(STREAM s) Line 412  rdp_out_bitmap_caps(STREAM s)
412          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
413          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
414    
415          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
416          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
417          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
418          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
419          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
420          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
421          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
422          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
423          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
424          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
425          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
426          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
# Line 354  rdp_out_order_caps(STREAM s) Line 437  rdp_out_order_caps(STREAM s)
437          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
438          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
439          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
440          order_caps[3] = 1;      /* required for memblt? */          order_caps[3] = (g_bitmap_cache ? 1 : 0); /* memblt */
441          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
442          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
443          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
444          order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
445          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
446          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
447          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
# Line 376  rdp_out_order_caps(STREAM s) Line 459  rdp_out_order_caps(STREAM s)
459          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
460          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
461          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
462          out_uint32_le(s, desktop_save == False ? 0 : 0x38400);  /* Desktop cache size */          out_uint32_le(s, g_desktop_save == False ? 0 : 0x38400);        /* Desktop cache size */
463          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
464          out_uint32_le(s, 0x4e4);        /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
465  }  }
# Line 385  rdp_out_order_caps(STREAM s) Line 468  rdp_out_order_caps(STREAM s)
468  static void  static void
469  rdp_out_bmpcache_caps(STREAM s)  rdp_out_bmpcache_caps(STREAM s)
470  {  {
471            int Bpp;
472          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
473          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
474    
475            Bpp = (g_server_bpp + 7) / 8;
476          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
477          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
478          out_uint16_le(s, 0x100);        /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
479          out_uint16_le(s, 0x12c);        /* entries */          out_uint16_le(s, 0x12c);        /* entries */
480          out_uint16_le(s, 0x400);        /* max cell size */          out_uint16_le(s, 0x400 * Bpp);  /* max cell size */
481          out_uint16_le(s, 0x106);        /* entries */          out_uint16_le(s, 0x106);        /* entries */
482          out_uint16_le(s, 0x1000);       /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
483  }  }
484    
485  /* Output control capability set */  /* Output control capability set */
# Line 494  static void Line 579  static void
579  rdp_send_confirm_active(void)  rdp_send_confirm_active(void)
580  {  {
581          STREAM s;          STREAM s;
582          uint32 sec_flags = encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;          uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
583          uint16 caplen =          uint16 caplen =
584                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
585                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
# Line 505  rdp_send_confirm_active(void) Line 590  rdp_send_confirm_active(void)
590    
591          out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));          out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));
592          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
593          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
594    
595          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
596          out_uint16_le(s, 0x3ea);        /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
597          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
598          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
# Line 531  rdp_send_confirm_active(void) Line 616  rdp_send_confirm_active(void)
616          sec_send(s, sec_flags);          sec_send(s, sec_flags);
617  }  }
618    
619    /* Process a general capability set */
620    static void
621    rdp_process_general_caps(STREAM s)
622    {
623            uint16 pad2octetsB;     /* rdp5 flags? */
624    
625            in_uint8s(s, 10);
626            in_uint16_le(s, pad2octetsB);
627    
628            if (!pad2octetsB)
629                    g_use_rdp5 = False;
630    }
631    
632    /* Process a bitmap capability set */
633    static void
634    rdp_process_bitmap_caps(STREAM s)
635    {
636            uint16 width, height, bpp;
637    
638            in_uint16_le(s, bpp);
639            in_uint8s(s, 6);
640    
641            in_uint16_le(s, width);
642            in_uint16_le(s, height);
643    
644            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
645    
646            /*
647             * The server may limit bpp and change the size of the desktop (for
648             * example when shadowing another session).
649             */
650            g_server_bpp = bpp;
651            g_width = width;
652            g_height = height;
653    
654            ui_resize_window();
655    }
656    
657  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
658  static void  static void
659  process_demand_active(STREAM s)  process_demand_active(STREAM s)
660  {  {
661          uint8 type;          int n;
662            uint8 type, *next;
663            uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;
664    
665            in_uint32_le(s, g_rdp_shareid);
666            in_uint16_le(s, len_src_descriptor);
667            in_uint16_le(s, len_combined_caps);
668            in_uint8s(s, len_src_descriptor);
669    
670          in_uint32_le(s, rdp_shareid);          in_uint16_le(s, num_capsets);
671            in_uint8s(s, 2);        /* pad */
672    
673            DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));
674    
675            for (n = 0; n < num_capsets; n++)
676            {
677                    in_uint16_le(s, capset_type);
678                    in_uint16_le(s, capset_length);
679    
680                    next = s->p + capset_length - 4;
681    
682                    switch (capset_type)
683                    {
684                            case RDP_CAPSET_GENERAL:
685                                    rdp_process_general_caps(s);
686                                    break;
687    
688          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));                          case RDP_CAPSET_BITMAP:
689                                    rdp_process_bitmap_caps(s);
690                                    break;
691                    }
692    
693                    s->p = next;
694            }
695    
696          rdp_send_confirm_active();          rdp_send_confirm_active();
697          rdp_send_synchronise();          rdp_send_synchronise();
# Line 548  process_demand_active(STREAM s) Line 700  process_demand_active(STREAM s)
700          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
701          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
702          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
703          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);
         rdp_send_fonts(1);  
         rdp_send_fonts(2);  
         rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */  
         reset_order_state();  
 }  
704    
705  /* Process a null system pointer PDU */          if (g_use_rdp5)
706  void          {
707  process_null_system_pointer_pdu(STREAM s)                  rdp_send_fonts(3);
708  {          }
709          // FIXME: We should probably set another cursor here,          else
710          // like the X window system base cursor or something.          {
711          ui_set_cursor(cache_get_cursor(0));                  rdp_send_fonts(1);
712                    rdp_send_fonts(2);
713            }
714    
715            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
716            reset_order_state();
717  }  }
718    
719  /* Process a colour pointer PDU */  /* Process a colour pointer PDU */
# Line 596  process_cached_pointer_pdu(STREAM s) Line 748  process_cached_pointer_pdu(STREAM s)
748          ui_set_cursor(cache_get_cursor(cache_idx));          ui_set_cursor(cache_get_cursor(cache_idx));
749  }  }
750    
751    /* Process a system pointer PDU */
752    void
753    process_system_pointer_pdu(STREAM s)
754    {
755            uint16 system_pointer_type;
756    
757            in_uint16(s, system_pointer_type);
758            switch (system_pointer_type)
759            {
760                    case RDP_NULL_POINTER:
761                            ui_set_null_cursor();
762                            break;
763    
764                    default:
765                            unimpl("System pointer message 0x%x\n", system_pointer_type);
766            }
767    }
768    
769  /* Process a pointer PDU */  /* Process a pointer PDU */
770  static void  static void
# Line 624  process_pointer_pdu(STREAM s) Line 793  process_pointer_pdu(STREAM s)
793                          process_cached_pointer_pdu(s);                          process_cached_pointer_pdu(s);
794                          break;                          break;
795    
796                    case RDP_POINTER_SYSTEM:
797                            process_system_pointer_pdu(s);
798                            break;
799    
800                  default:                  default:
801                          DEBUG(("Pointer message 0x%x\n", message_type));                          unimpl("Pointer message 0x%x\n", message_type);
802          }          }
803  }  }
804    
# Line 663  process_bitmap_updates(STREAM s) Line 836  process_bitmap_updates(STREAM s)
836                  if (!compress)                  if (!compress)
837                  {                  {
838                          int y;                          int y;
839                          bmpdata = xmalloc(width * height * Bpp);                          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
840                          for (y = 0; y < height; y++)                          for (y = 0; y < height; y++)
841                          {                          {
842                                  in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],                                  in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
# Line 686  process_bitmap_updates(STREAM s) Line 859  process_bitmap_updates(STREAM s)
859                          in_uint8s(s, 4);        /* line_size, final_size */                          in_uint8s(s, 4);        /* line_size, final_size */
860                  }                  }
861                  in_uint8p(s, data, size);                  in_uint8p(s, data, size);
862                  bmpdata = xmalloc(width * height * Bpp);                  bmpdata = (uint8 *) xmalloc(width * height * Bpp);
863                  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))                  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
864                  {                  {
865                          ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);                          ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
# Line 713  process_palette(STREAM s) Line 886  process_palette(STREAM s)
886          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
887          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
888    
889          map.colours = xmalloc(3 * map.ncolours);          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
890    
891          DEBUG(("PALETTE(c=%d)\n", map.ncolours));          DEBUG(("PALETTE(c=%d)\n", map.ncolours));
892    
# Line 765  process_update_pdu(STREAM s) Line 938  process_update_pdu(STREAM s)
938    
939  }  }
940    
941    /* Process a disconnect PDU */
942    void
943    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
944    {
945            in_uint32_le(s, *ext_disc_reason);
946    
947            DEBUG(("Received disconnect PDU\n"));
948    }
949    
950  /* Process data PDU */  /* Process data PDU */
951  static void  static BOOL
952  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
953  {  {
954          uint8 data_pdu_type;          uint8 data_pdu_type;
955            uint8 ctype;
956            uint16 clen;
957            int len;
958    #if 0
959            int roff, rlen, ret;
960            static struct stream ns;
961            static signed char *dict = 0;
962    #endif
963    
964          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          in_uint8s(s, 6);        /* shareid, pad, streamid */
965            in_uint16(s, len);
966          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
967          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
968            in_uint16(s, clen);
969            clen -= 18;
970    
971    #if 0
972            if (ctype & 0x20)
973            {
974                    if (!dict)
975                    {
976                            dict = (signed char *) malloc(8200 * sizeof(signed char));
977                            dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));
978                    }
979    
980                    ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);
981    
982                    len -= 18;
983    
984                    ns.data = xrealloc(ns.data, len);
985    
986                    ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);
987    
988                    ns.size = len;
989                    ns.end = ns.data + ns.size;
990                    ns.p = ns.data;
991                    ns.rdp_hdr = ns.p;
992    
993                    s = &ns;
994            }
995    #endif
996    
997          switch (data_pdu_type)          switch (data_pdu_type)
998          {          {
# Line 781  process_data_pdu(STREAM s) Line 1000  process_data_pdu(STREAM s)
1000                          process_update_pdu(s);                          process_update_pdu(s);
1001                          break;                          break;
1002    
1003                    case RDP_DATA_PDU_CONTROL:
1004                            DEBUG(("Received Control PDU\n"));
1005                            break;
1006    
1007                    case RDP_DATA_PDU_SYNCHRONISE:
1008                            DEBUG(("Received Sync PDU\n"));
1009                            break;
1010    
1011                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1012                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1013                          break;                          break;
# Line 794  process_data_pdu(STREAM s) Line 1021  process_data_pdu(STREAM s)
1021                          /* User logged on */                          /* User logged on */
1022                          break;                          break;
1023    
1024                    case RDP_DATA_PDU_DISCONNECT:
1025                            process_disconnect_pdu(s, ext_disc_reason);
1026                            return True;
1027    
1028                  default:                  default:
1029                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1030          }          }
1031            return False;
1032  }  }
1033    
1034  /* Process incoming packets */  /* Process incoming packets */
1035  void  void
1036  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1037  {  {
1038          uint8 type;          uint8 type;
1039            BOOL disc = False;      /* True when a disconnect PDU was received */
1040          STREAM s;          STREAM s;
1041    
1042          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 812  rdp_main_loop(void) Line 1045  rdp_main_loop(void)
1045                  {                  {
1046                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1047                                  process_demand_active(s);                                  process_demand_active(s);
1048                                    *deactivated = False;
1049                                  break;                                  break;
1050    
1051                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1052                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
1053                                    *deactivated = True;
1054                                  break;                                  break;
1055    
1056                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1057                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1058                                  break;                                  break;
1059    
1060                          case 0:                          case 0:
# Line 827  rdp_main_loop(void) Line 1063  rdp_main_loop(void)
1063                          default:                          default:
1064                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1065                  }                  }
1066    
1067                    if (disc)
1068                    {
1069                            return;
1070                    }
1071          }          }
1072            return;
1073  }  }
1074    
1075  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
# Line 835  BOOL Line 1077  BOOL
1077  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1078              char *command, char *directory)              char *command, char *directory)
1079  {  {
1080          if (!sec_connect(server, username))          if (!sec_connect(server, g_username))
1081                  return False;                  return False;
1082    
1083          rdp_send_logon_info(flags, domain, username, password, command, directory);          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1084          return True;          return True;
1085  }  }
1086    
Legend:
Removed from v.365  
changed lines
  Added in v.678
  ViewVC Help
Powered by ViewVC 1.1.26