/[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 21 by matty, Mon Oct 16 08:44:48 2000 UTC revision 562 by stargo, Thu Dec 11 17:20:01 2003 UTC
# Line 1  Line 1 
1  /*  /* -*- 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-2000     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 orders;  extern BOOL g_bitmap_compression;
27    extern BOOL g_orders;
28  unsigned char *next_packet;  extern BOOL g_encryption;
29  uint32 rdp_shareid;  extern BOOL g_desktop_save;
30    extern BOOL g_use_rdp5;
31  /* Initialise an RDP packet */  extern uint16 g_server_rdp_version;
32  static STREAM rdp_init(int maxlen)  extern int g_server_bpp;
 {  
         STREAM s;  
33    
34          s = sec_init(SEC_ENCRYPT, maxlen + 6);  uint8 *g_next_packet;
35          s_push_layer(s, rdp_hdr, 6);  uint32 g_rdp_shareid;
   
         return s;  
 }  
   
 /* Send an RDP packet */  
 static void rdp_send(STREAM s, uint8 pdu_type)  
 {  
         uint16 length;  
36    
37          s_pop_layer(s, rdp_hdr);  #if WITH_DEBUG
38          length = s->end - s->p;  static uint32 g_packetno;
39    #endif
         out_uint16_le(s, length);  
         out_uint16_le(s, (pdu_type | 0x10)); /* Version 1 */  
         out_uint16_le(s, (mcs_userid + 1001));  
   
         sec_send(s, SEC_ENCRYPT);  
 }  
40    
41  /* Receive an RDP packet */  /* Receive an RDP packet */
42  static STREAM rdp_recv(uint8 *type)  static STREAM
43    rdp_recv(uint8 * type)
44  {  {
45          static STREAM rdp_s;          static STREAM rdp_s;
46          uint16 length, pdu_type;          uint16 length, pdu_type;
47    
48          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
49          {          {
50                  rdp_s = sec_recv();                  rdp_s = sec_recv();
51                  if (rdp_s == NULL)                  if (rdp_s == NULL)
52                          return NULL;                          return NULL;
53    
54                  next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
55          }          }
56          else          else
57          {          {
58                  rdp_s->p = next_packet;                  rdp_s->p = g_next_packet;
59          }          }
60    
61          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
62            /* 32k packets are really 8, keepalive fix */
63            if (length == 0x8000)
64            {
65                    g_next_packet += 8;
66                    *type = 0;
67                    return rdp_s;
68            }
69          in_uint16_le(rdp_s, pdu_type);          in_uint16_le(rdp_s, pdu_type);
70          in_uint8s(rdp_s, 2); /* userid */          in_uint8s(rdp_s, 2);    /* userid */
   
         next_packet += length;  
71          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
72    
73  #if RDP_DEBUG  #if WITH_DEBUG
74          DEBUG("RDP packet (type %x):\n", *type);          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
75          hexdump(rdp_s->p, length);          hexdump(g_next_packet, length);
76  #endif  #endif /*  */
77    
78            g_next_packet += length;
79          return rdp_s;          return rdp_s;
80  }  }
81    
82  /* Initialise an RDP data packet */  /* Initialise an RDP data packet */
83  static STREAM rdp_init_data(int maxlen)  static STREAM
84    rdp_init_data(int maxlen)
85  {  {
86          STREAM s;          STREAM s;
87    
88          s = sec_init(SEC_ENCRYPT, maxlen + 18);          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
89          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
90    
91          return s;          return s;
92  }  }
93    
94  /* Send an RDP data packet */  /* Send an RDP data packet */
95  static void rdp_send_data(STREAM s, uint8 data_pdu_type)  static void
96    rdp_send_data(STREAM s, uint8 data_pdu_type)
97  {  {
98          uint16 length;          uint16 length;
99    
# Line 108  static void rdp_send_data(STREAM s, uint Line 102  static void rdp_send_data(STREAM s, uint
102    
103          out_uint16_le(s, length);          out_uint16_le(s, length);
104          out_uint16_le(s, (RDP_PDU_DATA | 0x10));          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
105          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
106    
107          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
108          out_uint8(s, 0);  /* pad */          out_uint8(s, 0);        /* pad */
109          out_uint8(s, 1);  /* streamid */          out_uint8(s, 1);        /* streamid */
110          out_uint16(s, (length - 14));          out_uint16_le(s, (length - 14));
111          out_uint8(s, data_pdu_type);          out_uint8(s, data_pdu_type);
112          out_uint8(s, 0);  /* compress_type */          out_uint8(s, 0);        /* compress_type */
113          out_uint16(s, 0); /* compress_len */          out_uint16(s, 0);       /* compress_len */
114    
115          sec_send(s, SEC_ENCRYPT);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
116  }  }
117    
118  /* Output a string in Unicode */  /* Output a string in Unicode */
119  void rdp_out_unistr(STREAM s, char *string, int len)  void
120    rdp_out_unistr(STREAM s, char *string, int len)
121  {  {
122          int i = 0, j = 0;          int i = 0, j = 0;
123    
# Line 138  void rdp_out_unistr(STREAM s, char *stri Line 133  void rdp_out_unistr(STREAM s, char *stri
133  }  }
134    
135  /* Parse a logon info packet */  /* Parse a logon info packet */
136  static void rdp_send_logon_info(uint32 flags, char *domain, char *user,  static void
137                                  char *password, char *program, char *directory)  rdp_send_logon_info(uint32 flags, char *domain, char *user,
138  {                      char *password, char *program, char *directory)
139          int len_domain    = 2 * strlen(domain);  {
140          int len_user      = 2 * strlen(user);          int len_domain = 2 * strlen(domain);
141          int len_password  = 2 * strlen(password);          int len_user = 2 * strlen(user);
142          int len_program   = 2 * strlen(program);          int len_password = 2 * strlen(password);
143            int len_program = 2 * strlen(program);
144          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
145          uint32 sec_flags = SEC_LOGON_INFO | SEC_ENCRYPT;          int len_ip = 2 * strlen("127.0.0.1");
146            int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
147            int packetlen = 0;
148            uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
149          STREAM s;          STREAM s;
150            time_t t = time(NULL);
151            time_t tzone;
152    
153          s = sec_init(sec_flags, 18 + len_domain + len_user + len_password          if (!g_use_rdp5 || 1 == g_server_rdp_version)
154                                          + len_program + len_directory + 10);          {
155                    DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
156    
157                    s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
158                                 + len_program + len_directory + 10);
159    
160                    out_uint32(s, 0);
161                    out_uint32_le(s, flags);
162                    out_uint16_le(s, len_domain);
163                    out_uint16_le(s, len_user);
164                    out_uint16_le(s, len_password);
165                    out_uint16_le(s, len_program);
166                    out_uint16_le(s, len_directory);
167                    rdp_out_unistr(s, domain, len_domain);
168                    rdp_out_unistr(s, user, len_user);
169                    rdp_out_unistr(s, password, len_password);
170                    rdp_out_unistr(s, program, len_program);
171                    rdp_out_unistr(s, directory, len_directory);
172            }
173            else
174            {
175                    flags |= RDP_LOGON_BLOB;
176                    DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
177                    packetlen = 4 + /* Unknown uint32 */
178                            4 +     /* flags */
179                            2 +     /* len_domain */
180                            2 +     /* len_user */
181                            (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
182                            (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
183                            2 +     /* len_program */
184                            2 +     /* len_directory */
185                            (0 < len_domain ? len_domain : 2) +     /* domain */
186                            len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
187                            (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
188                            (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
189                            2 +     /* Client ip length */
190                            len_ip +        /* Client ip */
191                            2 +     /* DLL string length */
192                            len_dll +       /* DLL string */
193                            2 +     /* Unknown */
194                            2 +     /* Unknown */
195                            64 +    /* Time zone #0 */
196                            2 +     /* Unknown */
197                            64 +    /* Time zone #1 */
198                            32;     /* Unknown */
199    
200                    s = sec_init(sec_flags, packetlen);
201                    DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
202    
203                    out_uint32(s, 0);       /* Unknown */
204                    out_uint32_le(s, flags);
205                    out_uint16_le(s, len_domain);
206                    out_uint16_le(s, len_user);
207                    if (flags & RDP_LOGON_AUTO)
208                    {
209                            out_uint16_le(s, len_password);
210    
211                    }
212                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
213                    {
214                            out_uint16_le(s, 0);
215                    }
216                    out_uint16_le(s, len_program);
217                    out_uint16_le(s, len_directory);
218                    if (0 < len_domain)
219                            rdp_out_unistr(s, domain, len_domain);
220                    else
221                            out_uint16_le(s, 0);
222                    rdp_out_unistr(s, user, len_user);
223                    if (flags & RDP_LOGON_AUTO)
224                    {
225                            rdp_out_unistr(s, password, len_password);
226                    }
227                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
228                    {
229                            out_uint16_le(s, 0);
230                    }
231                    if (0 < len_program)
232                    {
233                            rdp_out_unistr(s, program, len_program);
234    
235                    }
236                    else
237                    {
238                            out_uint16_le(s, 0);
239                    }
240                    if (0 < len_directory)
241                    {
242                            rdp_out_unistr(s, directory, len_directory);
243                    }
244                    else
245                    {
246                            out_uint16_le(s, 0);
247                    }
248                    out_uint16_le(s, 2);
249                    out_uint16_le(s, len_ip + 2);   /* Length of client ip */
250                    rdp_out_unistr(s, "127.0.0.1", len_ip);
251                    out_uint16_le(s, len_dll + 2);
252                    rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
253    
254                    tzone = (mktime(localtime(&t)) - mktime(gmtime(&t))) / 60;
255                    out_uint16_le(s, tzone);
256                    out_uint16_le(s, 0x0000);
257    
258                    rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
259                    out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
260    
261    
262                    out_uint32_le(s, 0x0a0000);
263                    out_uint32_le(s, 0x050000);
264                    out_uint32_le(s, 3);
265                    out_uint32_le(s, 0);
266                    out_uint32_le(s, 0);
267    
268                    rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid"));
269                    out_uint8s(s, 62 - 2 * strlen("GTB, sommartid"));
270    
271                    out_uint32_le(s, 0x30000);
272                    out_uint32_le(s, 0x050000);
273                    out_uint32_le(s, 2);
274                    out_uint32(s, 0);
275                    out_uint32_le(s, 0xffffffc4);
276                    out_uint32_le(s, 0xfffffffe);
277                    out_uint32_le(s, 0x0f);
278                    out_uint32(s, 0);
279    
         out_uint32(s, 0);  
         out_uint32_le(s, flags);  
         out_uint16_le(s, len_domain);  
         out_uint16_le(s, len_user);  
         out_uint16_le(s, len_password);  
         out_uint16_le(s, len_program);  
         out_uint16_le(s, len_directory);  
         rdp_out_unistr(s, domain,    len_domain);  
         rdp_out_unistr(s, user,      len_user);  
         rdp_out_unistr(s, password,  len_password);  
         rdp_out_unistr(s, program,   len_program);  
         rdp_out_unistr(s, directory, len_directory);  
280    
281            }
282          s_mark_end(s);          s_mark_end(s);
283          sec_send(s, sec_flags);          sec_send(s, sec_flags);
284  }  }
285    
286  /* Send a control PDU */  /* Send a control PDU */
287  static void rdp_send_control(uint16 action)  static void
288    rdp_send_control(uint16 action)
289  {  {
290          STREAM s;          STREAM s;
291    
292          s = rdp_init_data(8);          s = rdp_init_data(8);
293    
294          out_uint16_le(s, action);          out_uint16_le(s, action);
295          out_uint16(s, 0); /* userid */          out_uint16(s, 0);       /* userid */
296          out_uint32(s, 0); /* control id */          out_uint32(s, 0);       /* control id */
297    
298          s_mark_end(s);          s_mark_end(s);
299          rdp_send_data(s, RDP_DATA_PDU_CONTROL);          rdp_send_data(s, RDP_DATA_PDU_CONTROL);
300  }  }
301    
302  /* Send a synchronisation PDU */  /* Send a synchronisation PDU */
303  static void rdp_send_synchronise()  static void
304    rdp_send_synchronise(void)
305  {  {
306          STREAM s;          STREAM s;
307    
308          s = rdp_init_data(4);          s = rdp_init_data(4);
309    
310          out_uint16_le(s, 1); /* type */          out_uint16_le(s, 1);    /* type */
311          out_uint16_le(s, 1002);          out_uint16_le(s, 1002);
312    
313          s_mark_end(s);          s_mark_end(s);
# Line 199  static void rdp_send_synchronise() Line 315  static void rdp_send_synchronise()
315  }  }
316    
317  /* Send a single input event */  /* Send a single input event */
318  void rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags,  void
319                      uint16 param1, uint16 param2)  rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
320  {  {
321          STREAM s;          STREAM s;
322    
323          s = rdp_init_data(16);          s = rdp_init_data(16);
324    
325          out_uint16_le(s, 1); /* number of events */          out_uint16_le(s, 1);    /* number of events */
326          out_uint16(s, 0);    /* pad */          out_uint16(s, 0);       /* pad */
327    
328          out_uint32_le(s, time);          out_uint32_le(s, time);
329          out_uint16_le(s, message_type);          out_uint16_le(s, message_type);
# Line 220  void rdp_send_input(uint32 time, uint16 Line 336  void rdp_send_input(uint32 time, uint16
336  }  }
337    
338  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
339  static void rdp_send_fonts(uint16 seq)  static void
340    rdp_send_fonts(uint16 seq)
341  {  {
342          STREAM s;          STREAM s;
343    
# Line 236  static void rdp_send_fonts(uint16 seq) Line 353  static void rdp_send_fonts(uint16 seq)
353  }  }
354    
355  /* Output general capability set */  /* Output general capability set */
356  static void rdp_out_general_caps(STREAM s)  static void
357    rdp_out_general_caps(STREAM s)
358  {  {
359          out_uint16_le(s, RDP_CAPSET_GENERAL);          out_uint16_le(s, RDP_CAPSET_GENERAL);
360          out_uint16_le(s, RDP_CAPLEN_GENERAL);          out_uint16_le(s, RDP_CAPLEN_GENERAL);
361    
362          out_uint16_le(s, 1);    /* OS major type */          out_uint16_le(s, 1);    /* OS major type */
363          out_uint16_le(s, 3);    /* OS minor type */          out_uint16_le(s, 3);    /* OS minor type */
364          out_uint16_le(s, 0x200); /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
365          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
366          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
367          out_uint16(s, 0);       /* Pad */          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
368            /* Pad, according to T.128. 0x40d seems to
369               trigger
370               the server to start sending RDP5 packets.
371               However, the value is 0x1d04 with W2KTSK and
372               NT4MS. Hmm.. Anyway, thankyou, Microsoft,
373               for sending such information in a padding
374               field.. */
375          out_uint16(s, 0);       /* Update capability */          out_uint16(s, 0);       /* Update capability */
376          out_uint16(s, 0);       /* Remote unshare capability */          out_uint16(s, 0);       /* Remote unshare capability */
377          out_uint16(s, 0);       /* Compression level */          out_uint16(s, 0);       /* Compression level */
# Line 254  static void rdp_out_general_caps(STREAM Line 379  static void rdp_out_general_caps(STREAM
379  }  }
380    
381  /* Output bitmap capability set */  /* Output bitmap capability set */
382  static void rdp_out_bitmap_caps(STREAM s)  static void
383    rdp_out_bitmap_caps(STREAM s)
384  {  {
385          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
386          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
387    
388          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, 8);    /* Preferred BPP */
389          out_uint16(s, 1);       /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
390          out_uint16(s, 1);       /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
391          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
392          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
393          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
394          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
395          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 0);       /* Allow resize */
396          out_uint16_le(s, 1);    /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
397          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
398          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
399          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
400  }  }
401    
402  /* Output order capability set */  /* Output order capability set */
403  static void rdp_out_order_caps(STREAM s)  static void
404    rdp_out_order_caps(STREAM s)
405  {  {
406          uint8 order_caps[32];          uint8 order_caps[32];
407    
         memset(order_caps, orders, 32);  
408    
409            memset(order_caps, 0, 32);
410            order_caps[0] = 1;      /* dest blt */
411            order_caps[1] = 1;      /* pat blt */
412            order_caps[2] = 1;      /* screen blt */
413            order_caps[3] = 1;      /* required for memblt? */
414            order_caps[8] = 1;      /* line */
415            order_caps[9] = 1;      /* line */
416            order_caps[10] = 1;     /* rect */
417            order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
418            order_caps[13] = 1;     /* memblt */
419            order_caps[14] = 1;     /* triblt */
420            order_caps[22] = 1;     /* polyline */
421            order_caps[27] = 1;     /* text2 */
422          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
423          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
424    
# Line 289  static void rdp_out_order_caps(STREAM s) Line 428  static void rdp_out_order_caps(STREAM s)
428          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
429          out_uint16_le(s, 1);    /* Max order level */          out_uint16_le(s, 1);    /* Max order level */
430          out_uint16_le(s, 0x147);        /* Number of fonts */          out_uint16_le(s, 0x147);        /* Number of fonts */
431          out_uint16_le(s, 0x2a);         /* Capability flags */          out_uint16_le(s, 0x2a); /* Capability flags */
432          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
433          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
434          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
435          out_uint32(s, 0x38400); /* Desktop cache size */          out_uint32_le(s, g_desktop_save == False ? 0 : 0x38400);        /* Desktop cache size */
436          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
437          out_uint32(s, 0x4e4);   /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
438  }  }
439    
440  /* Output bitmap cache capability set */  /* Output bitmap cache capability set */
441  static void rdp_out_bmpcache_caps(STREAM s)  static void
442    rdp_out_bmpcache_caps(STREAM s)
443  {  {
444            int Bpp;
445          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
446          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
447    
448          out_uint8s(s, 24); /* unused */          Bpp = (g_server_bpp + 7) / 8;
449          out_uint16_le(s, 0x258); /* entries */          out_uint8s(s, 24);      /* unused */
450          out_uint16_le(s, 0x100); /* max cell size */          out_uint16_le(s, 0x258);        /* entries */
451          out_uint16_le(s, 0x12c); /* entries */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
452          out_uint16_le(s, 0x400); /* max cell size */          out_uint16_le(s, 0x12c);        /* entries */
453          out_uint16_le(s, 0x106); /* entries */          out_uint16_le(s, 0x400 * Bpp);  /* max cell size */
454          out_uint16_le(s, 0x1000); /* max cell size */          out_uint16_le(s, 0x106);        /* entries */
455            out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
456  }  }
457    
458  /* Output control capability set */  /* Output control capability set */
459  static void rdp_out_control_caps(STREAM s)  static void
460    rdp_out_control_caps(STREAM s)
461  {  {
462          out_uint16_le(s, RDP_CAPSET_CONTROL);          out_uint16_le(s, RDP_CAPSET_CONTROL);
463          out_uint16_le(s, RDP_CAPLEN_CONTROL);          out_uint16_le(s, RDP_CAPLEN_CONTROL);
# Line 326  static void rdp_out_control_caps(STREAM Line 469  static void rdp_out_control_caps(STREAM
469  }  }
470    
471  /* Output activation capability set */  /* Output activation capability set */
472  static void rdp_out_activate_caps(STREAM s)  static void
473    rdp_out_activate_caps(STREAM s)
474  {  {
475          out_uint16_le(s, RDP_CAPSET_ACTIVATE);          out_uint16_le(s, RDP_CAPSET_ACTIVATE);
476          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
# Line 338  static void rdp_out_activate_caps(STREAM Line 482  static void rdp_out_activate_caps(STREAM
482  }  }
483    
484  /* Output pointer capability set */  /* Output pointer capability set */
485  static void rdp_out_pointer_caps(STREAM s)  static void
486    rdp_out_pointer_caps(STREAM s)
487  {  {
488          out_uint16_le(s, RDP_CAPSET_POINTER);          out_uint16_le(s, RDP_CAPSET_POINTER);
489          out_uint16_le(s, RDP_CAPLEN_POINTER);          out_uint16_le(s, RDP_CAPLEN_POINTER);
# Line 348  static void rdp_out_pointer_caps(STREAM Line 493  static void rdp_out_pointer_caps(STREAM
493  }  }
494    
495  /* Output share capability set */  /* Output share capability set */
496  static void rdp_out_share_caps(STREAM s)  static void
497    rdp_out_share_caps(STREAM s)
498  {  {
499          out_uint16_le(s, RDP_CAPSET_SHARE);          out_uint16_le(s, RDP_CAPSET_SHARE);
500          out_uint16_le(s, RDP_CAPLEN_SHARE);          out_uint16_le(s, RDP_CAPLEN_SHARE);
# Line 358  static void rdp_out_share_caps(STREAM s) Line 504  static void rdp_out_share_caps(STREAM s)
504  }  }
505    
506  /* Output colour cache capability set */  /* Output colour cache capability set */
507  static void rdp_out_colcache_caps(STREAM s)  static void
508    rdp_out_colcache_caps(STREAM s)
509  {  {
510          out_uint16_le(s, RDP_CAPSET_COLCACHE);          out_uint16_le(s, RDP_CAPSET_COLCACHE);
511          out_uint16_le(s, RDP_CAPLEN_COLCACHE);          out_uint16_le(s, RDP_CAPLEN_COLCACHE);
# Line 368  static void rdp_out_colcache_caps(STREAM Line 515  static void rdp_out_colcache_caps(STREAM
515  }  }
516    
517  static uint8 canned_caps[] = {  static uint8 canned_caps[] = {
518  0x01,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
519  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
520  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
521  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
522  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
523  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x08,0x00,0x01,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
524  0x00,0x00,0x00,0x0E,0x00,0x08,0x00,0x01,0x00,0x00,0x00,0x10,0x00,0x34,0x00,0xFE,          0x00, 0x00, 0x00, 0x00, 0x00,
525  0x00,0x04,0x00,0xFE,0x00,0x04,0x00,0xFE,0x00,0x08,0x00,0xFE,0x00,0x08,0x00,0xFE,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
526  0x00,0x10,0x00,0xFE,0x00,0x20,0x00,0xFE,0x00,0x40,0x00,0xFE,0x00,0x80,0x00,0xFE,          0x00, 0x00, 0x00, 0x00, 0x00,
527  0x00,0x00,0x01,0x40,0x00,0x00,0x08,0x00,0x01,0x00,0x01,0x02,0x00,0x00,0x00          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
528            0x0C, 0x00, 0x08, 0x00, 0x01,
529            0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
530            0x10, 0x00, 0x34, 0x00, 0xFE,
531            0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
532            0xFE, 0x00, 0x08, 0x00, 0xFE,
533            0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
534            0xFE, 0x00, 0x80, 0x00, 0xFE,
535            0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
536            0x02, 0x00, 0x00, 0x00
537  };  };
538    
539  /* Output unknown capability set */  /* Output unknown capability sets (number 13, 12, 14 and 16) */
540  static void rdp_out_unknown_caps(STREAM s)  static void
541    rdp_out_unknown_caps(STREAM s)
542  {  {
543          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, RDP_CAPSET_UNKNOWN);
544          out_uint16_le(s, 0x58);          out_uint16_le(s, 0x58);
545            
546          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN-4);          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);
547  }  }
548    
549    #define RDP5_FLAG 0x0030
550  /* Send a confirm active PDU */  /* Send a confirm active PDU */
551  static void rdp_send_confirm_active()  static void
552    rdp_send_confirm_active(void)
553  {  {
554          STREAM s;          STREAM s;
555          uint16 caplen = RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER          uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
556                  + RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE + RDP_CAPLEN_ACTIVATE          uint16 caplen =
557                  + RDP_CAPLEN_CONTROL + RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
558                  + RDP_CAPLEN_UNKNOWN;                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
559                    RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
560          s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
561    
562            s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
563    
564            out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));
565            out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
566            out_uint16_le(s, (g_mcs_userid + 1001));
567    
568          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
569          out_uint16_le(s, 0x3ea); /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
570          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
571          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
572    
573          out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));          out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));
574          out_uint16_le(s, 0xd); /* num_caps */          out_uint16_le(s, 0xd);  /* num_caps */
575          out_uint8s(s, 2);     /* pad */          out_uint8s(s, 2);       /* pad */
576    
577          rdp_out_general_caps(s);          rdp_out_general_caps(s);
578          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
# Line 421  static void rdp_send_confirm_active() Line 586  static void rdp_send_confirm_active()
586          rdp_out_unknown_caps(s);          rdp_out_unknown_caps(s);
587    
588          s_mark_end(s);          s_mark_end(s);
589          rdp_send(s, RDP_PDU_CONFIRM_ACTIVE);          sec_send(s, sec_flags);
590  }  }
591    
592  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
593  static void process_demand_active(STREAM s)  static void
594    process_demand_active(STREAM s)
595  {  {
596          uint8 type;          uint8 type;
597    
598          in_uint32_le(s, rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
599    
600          DEBUG("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid);          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
601    
602          rdp_send_confirm_active();          rdp_send_confirm_active();
603          rdp_send_synchronise();          rdp_send_synchronise();
604          rdp_send_control(RDP_CTL_COOPERATE);          rdp_send_control(RDP_CTL_COOPERATE);
605          rdp_send_control(RDP_CTL_REQUEST_CONTROL);          rdp_send_control(RDP_CTL_REQUEST_CONTROL);
606          rdp_recv(&type); // RDP_PDU_SYNCHRONIZE          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
607          rdp_recv(&type); // RDP_CTL_COOPERATE          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
608          rdp_recv(&type); // RDP_CTL_GRANT_CONTROL          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
609          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);
610          rdp_send_fonts(1);          rdp_send_fonts(1);
611          rdp_send_fonts(2);          rdp_send_fonts(2);
612          rdp_recv(&type); // RDP_PDU_UNKNOWN 0x28          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
613          reset_order_state();          reset_order_state();
614  }  }
615    
616    /* Process a colour pointer PDU */
617    void
618    process_colour_pointer_pdu(STREAM s)
619    {
620            uint16 x, y, width, height, cache_idx, masklen, datalen;
621            uint8 *mask, *data;
622            HCURSOR cursor;
623    
624            in_uint16_le(s, cache_idx);
625            in_uint16_le(s, x);
626            in_uint16_le(s, y);
627            in_uint16_le(s, width);
628            in_uint16_le(s, height);
629            in_uint16_le(s, masklen);
630            in_uint16_le(s, datalen);
631            in_uint8p(s, data, datalen);
632            in_uint8p(s, mask, masklen);
633            cursor = ui_create_cursor(x, y, width, height, mask, data);
634            ui_set_cursor(cursor);
635            cache_put_cursor(cache_idx, cursor);
636    }
637    
638    /* Process a cached pointer PDU */
639    void
640    process_cached_pointer_pdu(STREAM s)
641    {
642            uint16 cache_idx;
643    
644            in_uint16_le(s, cache_idx);
645            ui_set_cursor(cache_get_cursor(cache_idx));
646    }
647    
648    /* Process a system pointer PDU */
649    void
650    process_system_pointer_pdu(STREAM s)
651    {
652            uint16 system_pointer_type;
653    
654            in_uint16(s, system_pointer_type);
655            switch (system_pointer_type)
656            {
657                    case RDP_NULL_POINTER:
658                            ui_set_null_cursor();
659                            break;
660    
661                    default:
662                            unimpl("System pointer message 0x%x\n", system_pointer_type);
663            }
664    }
665    
666  /* Process a pointer PDU */  /* Process a pointer PDU */
667  static void process_pointer_pdu(STREAM s)  static void
668    process_pointer_pdu(STREAM s)
669  {  {
670          uint16 message_type;          uint16 message_type;
671          uint16 x, y;          uint16 x, y;
672    
673          in_uint16_le(s, message_type);          in_uint16_le(s, message_type);
674          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
675    
676          switch (message_type)          switch (message_type)
677          {          {
# Line 465  static void process_pointer_pdu(STREAM s Line 682  static void process_pointer_pdu(STREAM s
682                                  ui_move_pointer(x, y);                                  ui_move_pointer(x, y);
683                          break;                          break;
684    
685                    case RDP_POINTER_COLOR:
686                            process_colour_pointer_pdu(s);
687                            break;
688    
689                    case RDP_POINTER_CACHED:
690                            process_cached_pointer_pdu(s);
691                            break;
692    
693                    case RDP_POINTER_SYSTEM:
694                            process_system_pointer_pdu(s);
695                            break;
696    
697                  default:                  default:
698                          DEBUG("Pointer message 0x%x\n", message_type);                          unimpl("Pointer message 0x%x\n", message_type);
699          }          }
700  }  }
701    
702  /* Process bitmap updates */  /* Process bitmap updates */
703  static void process_bitmap_updates(STREAM s)  void
704    process_bitmap_updates(STREAM s)
705  {  {
706          uint16 num_updates;          uint16 num_updates;
707          uint16 left, top, right, bottom, width, height;          uint16 left, top, right, bottom, width, height;
708          uint16 cx, cy, bpp, compress, bufsize, size;          uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
709          uint8 *data, *rawdata;          uint8 *data, *bmpdata;
710          int i;          int i;
711    
712          in_uint16_le(s, num_updates);          in_uint16_le(s, num_updates);
# Line 490  static void process_bitmap_updates(STREA Line 720  static void process_bitmap_updates(STREA
720                  in_uint16_le(s, width);                  in_uint16_le(s, width);
721                  in_uint16_le(s, height);                  in_uint16_le(s, height);
722                  in_uint16_le(s, bpp);                  in_uint16_le(s, bpp);
723                    Bpp = (bpp + 7) / 8;
724                  in_uint16_le(s, compress);                  in_uint16_le(s, compress);
725                  in_uint16_le(s, bufsize);                  in_uint16_le(s, bufsize);
726    
727                  cx = right - left + 1;                  cx = right - left + 1;
728                  cy = bottom - top + 1;                  cy = bottom - top + 1;
729    
730                  DEBUG("UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,cmp=%d)\n",                  DEBUG(("BITMAP_UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,Bpp=%d,cmp=%d)\n",
731                          left, top, right, bottom, width, height, compress);                         left, top, right, bottom, width, height, Bpp, compress));
732    
733                    /* Server may limit bpp - this is how we find out */
734                    if (g_server_bpp != bpp)
735                    {
736                            warning("Server limited colour depth to %d bits\n", bpp);
737                            g_server_bpp = bpp;
738                    }
739    
740                  if (!compress)                  if (!compress)
741                  {                  {
742                          in_uint8p(s, data, bufsize);                          int y;
743                          ui_paint_bitmap(left, top, cx, cy, width, height, data);                          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
744                          return;                          for (y = 0; y < height; y++)
745                            {
746                                    in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
747                                              width * Bpp);
748                            }
749                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
750                            xfree(bmpdata);
751                            continue;
752                  }                  }
753    
                 in_uint8s(s, 2); /* pad */  
                 in_uint16_le(s, size);  
                 in_uint8s(s, 4); /* line_size, final_size */  
                 in_uint8p(s, data, size);  
754    
755                  rawdata = xmalloc(width * height);                  if (compress & 0x400)
756                  if (bitmap_decompress(rawdata, width, height, data, size))                  {
757                            size = bufsize;
758                    }
759                    else
760                    {
761                            in_uint8s(s, 2);        /* pad */
762                            in_uint16_le(s, size);
763                            in_uint8s(s, 4);        /* line_size, final_size */
764                    }
765                    in_uint8p(s, data, size);
766                    bmpdata = (uint8 *) xmalloc(width * height * Bpp);
767                    if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
768                    {
769                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
770                    }
771                    else
772                  {                  {
773                          ui_paint_bitmap(left, top, cx, cy, width, height,                          DEBUG_RDP5(("Failed to decompress data\n"));
                                         rawdata);  
774                  }                  }
775    
776                  xfree(rawdata);                  xfree(bmpdata);
777          }          }
778  }  }
779    
780  /* Process a palette update */  /* Process a palette update */
781  static void process_palette(STREAM s)  void
782    process_palette(STREAM s)
783  {  {
784          HCOLOURMAP hmap;          COLOURENTRY *entry;
785          COLOURMAP map;          COLOURMAP map;
786            HCOLOURMAP hmap;
787            int i;
788    
789          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
790          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
791          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
792          in_uint8p(s, (uint8 *)map.colours, (map.ncolours * 3));  
793            map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
794    
795            DEBUG(("PALETTE(c=%d)\n", map.ncolours));
796    
797            for (i = 0; i < map.ncolours; i++)
798            {
799                    entry = &map.colours[i];
800                    in_uint8(s, entry->red);
801                    in_uint8(s, entry->green);
802                    in_uint8(s, entry->blue);
803            }
804    
805          hmap = ui_create_colourmap(&map);          hmap = ui_create_colourmap(&map);
806          ui_set_colourmap(hmap);          ui_set_colourmap(hmap);
807    
808            xfree(map.colours);
809  }  }
810    
811  /* Process an update PDU */  /* Process an update PDU */
812  static void process_update_pdu(STREAM s)  static void
813    process_update_pdu(STREAM s)
814  {  {
815          uint16 update_type;          uint16 update_type, count;
816    
817          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
818    
819          switch (update_type)          switch (update_type)
820          {          {
821                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
822                          process_orders(s);                          in_uint8s(s, 2);        /* pad */
823                            in_uint16_le(s, count);
824                            in_uint8s(s, 2);        /* pad */
825                            process_orders(s, count);
826                          break;                          break;
827    
828                  case RDP_UPDATE_BITMAP:                  case RDP_UPDATE_BITMAP:
# Line 562  static void process_update_pdu(STREAM s) Line 837  static void process_update_pdu(STREAM s)
837                          break;                          break;
838    
839                  default:                  default:
840                          NOTIMP("update %d\n", update_type);                          unimpl("update %d\n", update_type);
841          }          }
842    
843  }  }
844    
845  /* Process data PDU */  /* Process data PDU */
846  static void process_data_pdu(STREAM s)  static void
847    process_data_pdu(STREAM s)
848  {  {
849          uint8 data_pdu_type;          uint8 data_pdu_type;
850    
851          in_uint8s(s, 8); /* shareid, pad, streamid, length */          in_uint8s(s, 8);        /* shareid, pad, streamid, length */
852          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
853          in_uint8s(s, 3); /* compress_type, compress_len */          in_uint8s(s, 3);        /* compress_type, compress_len */
854    
855          switch (data_pdu_type)          switch (data_pdu_type)
856          {          {
# Line 591  static void process_data_pdu(STREAM s) Line 867  static void process_data_pdu(STREAM s)
867                          break;                          break;
868    
869                  case RDP_DATA_PDU_LOGON:                  case RDP_DATA_PDU_LOGON:
870                            DEBUG(("Received Logon PDU\n"));
871                          /* User logged on */                          /* User logged on */
872                          break;                          break;
873    
874                    case RDP_DATA_PDU_DISCONNECT:
875                            /* Normally received when user logs out or disconnects from a
876                               console session on Windows XP and 2003 Server */
877                            DEBUG(("Received disconnect PDU\n"));
878                            break;
879    
880                  default:                  default:
881                          NOTIMP("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
882          }          }
883  }  }
884    
885  /* Process incoming packets */  /* Process incoming packets */
886  void rdp_main_loop()  BOOL
887    rdp_main_loop(void)
888  {  {
889          uint8 type;          uint8 type;
890          STREAM s;          STREAM s;
# Line 614  void rdp_main_loop() Line 898  void rdp_main_loop()
898                                  break;                                  break;
899    
900                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
901                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
902                                    /* We thought we could detect a clean
903                                       shutdown of the session by this
904                                       packet, but it seems Windows 2003
905                                       is sending us one of these when we
906                                       reconnect to a disconnected session
907                                       return True; */
908                                  break;                                  break;
909    
910                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
911                                  process_data_pdu(s);                                  process_data_pdu(s);
912                                  break;                                  break;
913    
914                            case 0:
915                                    break;
916    
917                          default:                          default:
918                                  NOTIMP("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
919                  }                  }
920          }          }
921            return True;
922            /* We want to detect if we got a clean shutdown, but we
923               can't. Se above.  
924               return False;  */
925  }  }
926    
927  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
928  BOOL rdp_connect(char *server, uint32 flags, char *domain, char *password,  BOOL
929                          char *command, char *directory)  rdp_connect(char *server, uint32 flags, char *domain, char *password,
930                char *command, char *directory)
931  {  {
932          if (!sec_connect(server))          if (!sec_connect(server, g_username))
933                  return False;                  return False;
934    
935          rdp_send_logon_info(flags, domain, username, password,          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
                                 command, directory);  
936          return True;          return True;
937  }  }
938    
939  /* Disconnect from the RDP layer */  /* Disconnect from the RDP layer */
940  void rdp_disconnect()  void
941    rdp_disconnect(void)
942  {  {
943          sec_disconnect();          sec_disconnect();
944  }  }
   
Legend:
Removed from v.21  
changed lines
  Added in v.562
  ViewVC Help
Powered by ViewVC 1.1.26