/[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 775 by jsorg71, Sat Oct 2 01:01:57 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    extern BOOL g_bitmap_cache_persist_enable;
38    
39  uint8 *next_packet;  uint8 *g_next_packet;
40  uint32 rdp_shareid;  uint32 g_rdp_shareid;
41    
42    extern RDPCOMP g_mppc_dict;
43    
44  #if WITH_DEBUG  #if WITH_DEBUG
45  static uint32 packetno;  static uint32 g_packetno;
46  #endif  #endif
47    
48  /* Receive an RDP packet */  /* Receive an RDP packet */
# Line 42  rdp_recv(uint8 * type) Line 51  rdp_recv(uint8 * type)
51  {  {
52          static STREAM rdp_s;          static STREAM rdp_s;
53          uint16 length, pdu_type;          uint16 length, pdu_type;
54            uint8 rdpver;
55    
56          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
57          {          {
58                  rdp_s = sec_recv();                  rdp_s = sec_recv(&rdpver);
59                  if (rdp_s == NULL)                  if (rdp_s == NULL)
60                          return NULL;                          return NULL;
61                    if (rdpver != 3)
62                    {
63                            /* rdp5_process should move g_next_packet ok */
64                            rdp5_process(rdp_s);
65                            *type = 0;
66                            return rdp_s;
67                    }
68    
69                  next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
70          }          }
71          else          else
72          {          {
73                  rdp_s->p = next_packet;                  rdp_s->p = g_next_packet;
74          }          }
75    
76          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
77          /* 32k packets are really 8, keepalive fix */          /* 32k packets are really 8, keepalive fix */
78          if (length == 0x8000)          if (length == 0x8000)
79          {          {
80                  next_packet += 8;                  g_next_packet += 8;
81                  *type = 0;                  *type = 0;
82                  return rdp_s;                  return rdp_s;
83          }          }
# Line 69  rdp_recv(uint8 * type) Line 86  rdp_recv(uint8 * type)
86          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
87    
88  #if WITH_DEBUG  #if WITH_DEBUG
89          DEBUG(("RDP packet #%d, (type %x)\n", ++packetno, *type));          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
90          //      hexdump(next_packet, length);          hexdump(g_next_packet, length);
91  #endif /*  */  #endif /*  */
92    
93          next_packet += length;          g_next_packet += length;
94          return rdp_s;          return rdp_s;
95  }  }
96    
# Line 83  rdp_init_data(int maxlen) Line 100  rdp_init_data(int maxlen)
100  {  {
101          STREAM s;          STREAM s;
102    
103          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
104          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
105    
106          return s;          return s;
# Line 100  rdp_send_data(STREAM s, uint8 data_pdu_t Line 117  rdp_send_data(STREAM s, uint8 data_pdu_t
117    
118          out_uint16_le(s, length);          out_uint16_le(s, length);
119          out_uint16_le(s, (RDP_PDU_DATA | 0x10));          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
120          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
121    
122          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
123          out_uint8(s, 0);        /* pad */          out_uint8(s, 0);        /* pad */
124          out_uint8(s, 1);        /* streamid */          out_uint8(s, 1);        /* streamid */
125          out_uint16_le(s, (length - 14));          out_uint16_le(s, (length - 14));
# Line 110  rdp_send_data(STREAM s, uint8 data_pdu_t Line 127  rdp_send_data(STREAM s, uint8 data_pdu_t
127          out_uint8(s, 0);        /* compress_type */          out_uint8(s, 0);        /* compress_type */
128          out_uint16(s, 0);       /* compress_len */          out_uint16(s, 0);       /* compress_len */
129    
130          sec_send(s, encryption ? SEC_ENCRYPT : 0);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
131  }  }
132    
133  /* Output a string in Unicode */  /* Output a string in Unicode */
# Line 130  rdp_out_unistr(STREAM s, char *string, i Line 147  rdp_out_unistr(STREAM s, char *string, i
147          s->p += len;          s->p += len;
148  }  }
149    
150    /* Input a string in Unicode
151     *
152     * Returns str_len of string
153     */
154    int
155    rdp_in_unistr(STREAM s, char *string, int uni_len)
156    {
157            int i = 0;
158    
159            while (i < uni_len / 2)
160            {
161                    in_uint8a(s, &string[i++], 1);
162                    in_uint8s(s, 1);
163            }
164    
165            return i - 1;
166    }
167    
168    
169  /* Parse a logon info packet */  /* Parse a logon info packet */
170  static void  static void
171  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
172                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
173  {  {
174            char *ipaddr = tcp_get_address();
175          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
176          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
177          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
178          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
179          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
180          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;          int len_ip = 2 * strlen(ipaddr);
181            int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
182            int packetlen = 0;
183            uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
184          STREAM s;          STREAM s;
185            time_t t = time(NULL);
186            time_t tzone;
187    
188          if (1 == server_rdp_version)  #if 0
189            /* enable rdp compression */
190            /* some problems still exist with rdp5 */
191            flags |= RDP_COMPRESSION;
192    #endif
193    
194            if (!g_use_rdp5 || 1 == g_server_rdp_version)
195          {          {
196                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
197    
# Line 165  rdp_send_logon_info(uint32 flags, char * Line 213  rdp_send_logon_info(uint32 flags, char *
213          }          }
214          else          else
215          {          {
216    
217                    flags |= RDP_LOGON_BLOB;
218                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
219                  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 */
220                            4 +     /* flags */
221                            2 +     /* len_domain */
222                            2 +     /* len_user */
223                            (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
224                            (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
225                            2 +     /* len_program */
226                            2 +     /* len_directory */
227                            (0 < len_domain ? len_domain : 2) +     /* domain */
228                            len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
229                            (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
230                            (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
231                            2 +     /* Client ip length */
232                            len_ip +        /* Client ip */
233                            2 +     /* DLL string length */
234                            len_dll +       /* DLL string */
235                            2 +     /* Unknown */
236                            2 +     /* Unknown */
237                            64 +    /* Time zone #0 */
238                            2 +     /* Unknown */
239                            64 +    /* Time zone #1 */
240                            32;     /* Unknown */
241    
242                  out_uint32(s, 0);                  s = sec_init(sec_flags, packetlen);
243                    DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
244    
245                    out_uint32(s, 0);       /* Unknown */
246                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
247                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
248                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
249                  if (flags & RDP_LOGON_AUTO)                  if (flags & RDP_LOGON_AUTO)
250                  {                  {
251                          out_uint16_le(s, len_password);                          out_uint16_le(s, len_password);
252    
253                    }
254                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
255                    {
256                            out_uint16_le(s, 0);
257                  }                  }
                 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 */  
258                  out_uint16_le(s, len_program);                  out_uint16_le(s, len_program);
259                  out_uint16_le(s, len_directory);                  out_uint16_le(s, len_directory);
260                    if (0 < len_domain)
261                            rdp_out_unistr(s, domain, len_domain);
262                    else
263                            out_uint16_le(s, 0);
264                    rdp_out_unistr(s, user, len_user);
265                  if (flags & RDP_LOGON_AUTO)                  if (flags & RDP_LOGON_AUTO)
266                  {                  {
267                          rdp_out_unistr(s, password, len_password);                          rdp_out_unistr(s, password, len_password);
268                  }                  }
269                  rdp_out_unistr(s, domain, len_domain);                  if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
270                  rdp_out_unistr(s, user, len_user);                  {
271                  out_uint16(s, 0);                          out_uint16_le(s, 0);
272                  out_uint16(s, 0);                  }
273                  if (0 < len_program)                  if (0 < len_program)
274                    {
275                          rdp_out_unistr(s, program, len_program);                          rdp_out_unistr(s, program, len_program);
276    
277                    }
278                    else
279                    {
280                            out_uint16_le(s, 0);
281                    }
282                  if (0 < len_directory)                  if (0 < len_directory)
283                    {
284                          rdp_out_unistr(s, directory, len_directory);                          rdp_out_unistr(s, directory, len_directory);
285                  out_uint8s(s, 30);      /* Some kind of client data - let's see if the server                  }
286                                             handles zeros well.. */                  else
287                  out_uint16_le(s, 60);                  {
288                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", 58);                          out_uint16_le(s, 0);
289                  out_uint32_be(s, 0x88ffffff);                  }
290                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid") - 2);                  out_uint16_le(s, 2);
291                  out_uint8s(s, 30 - 2 * strlen("GTP, normaltid"));                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
292                    rdp_out_unistr(s, ipaddr, len_ip);
293                    out_uint16_le(s, len_dll + 2);
294                    rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
295    
296                    tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
297                    out_uint32_le(s, tzone);
298    
299                    rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
300                    out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
301    
302                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
303                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
304                  out_uint32_le(s, 2);                  out_uint32_le(s, 3);
305                  out_uint32(s, 0);                  out_uint32_le(s, 0);
306                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0);
                 out_uint32_le(s, 0xfffffffe);  
                 out_uint32_le(s, 0x0f);  
                 out_uint32(s, 0);  
307    
308                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid") - 1);                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid"));
309                  out_uint8s(s, 30 - 2 * strlen("GTP, sommartid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, sommartid"));
310    
311                  out_uint32_le(s, 0x030000);                  out_uint32_le(s, 0x30000);
312                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
313                  out_uint32_le(s, 2);                  out_uint32_le(s, 2);
314                  out_uint32(s, 0);                  out_uint32(s, 0);
315                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
316                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
317                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
318                  out_uint32(s, 0);                  out_uint32(s, 0);
319    
320    
321          }          }
322          s_mark_end(s);          s_mark_end(s);
323          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 279  rdp_send_input(uint32 time, uint16 messa Line 375  rdp_send_input(uint32 time, uint16 messa
375          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
376  }  }
377    
378    /* Inform the server on the contents of the persistent bitmap cache */
379    static void
380    rdp_enum_bmpcache2(void)
381    {
382            STREAM s;
383            uint8 idlist[BMPCACHE2_NUM_PSTCELLS * sizeof(BITMAP_ID)];
384            uint32 nids, offset, count, flags;
385    
386            offset = 0;
387            nids = pstcache_enumerate(2, idlist);
388    
389            while (offset < nids)
390            {
391                    count = MIN(nids - offset, 169);
392    
393                    s = rdp_init_data(24 + count * sizeof(BITMAP_ID));
394    
395                    flags = 0;
396                    if (offset == 0)
397                            flags |= PDU_FLAG_FIRST;
398                    if (nids - offset <= 169)
399                            flags |= PDU_FLAG_LAST;
400    
401                    /* header */
402                    out_uint32_le(s, 0);
403                    out_uint16_le(s, count);
404                    out_uint16_le(s, 0);
405                    out_uint16_le(s, 0);
406                    out_uint16_le(s, 0);
407                    out_uint16_le(s, 0);
408                    out_uint16_le(s, nids);
409                    out_uint32_le(s, 0);
410                    out_uint32_le(s, flags);
411    
412                    /* list */
413                    out_uint8a(s, idlist + offset * sizeof(BITMAP_ID), count * sizeof(BITMAP_ID));
414    
415                    s_mark_end(s);
416                    rdp_send_data(s, 0x2b);
417    
418                    offset += 169;
419            }
420    }
421    
422  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
423  static void  static void
424  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 288  rdp_send_fonts(uint16 seq) Line 428  rdp_send_fonts(uint16 seq)
428          s = rdp_init_data(8);          s = rdp_init_data(8);
429    
430          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
431          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
432          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
433          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
434    
# Line 308  rdp_out_general_caps(STREAM s) Line 448  rdp_out_general_caps(STREAM s)
448          out_uint16_le(s, 0x200);        /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
449          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
450          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
451          out_uint16_le(s, use_rdp5 ? 0x40d : 0);          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
452          /* Pad, according to T.128. 0x40d seems to          /* Pad, according to T.128. 0x40d seems to
453             trigger             trigger
454             the server to start sending RDP5 packets.             the server to start sending RDP5 packets.
# Line 329  rdp_out_bitmap_caps(STREAM s) Line 469  rdp_out_bitmap_caps(STREAM s)
469          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
470          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
471    
472          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
473          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
474          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
475          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
476          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
477          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
478          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
479          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
480          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
481          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
482          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
483          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
# Line 354  rdp_out_order_caps(STREAM s) Line 494  rdp_out_order_caps(STREAM s)
494          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
495          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
496          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
497          order_caps[3] = 1;      /* required for memblt? */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
498          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
499          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
500          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
501          order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
502          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
503          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
504          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
# Line 376  rdp_out_order_caps(STREAM s) Line 516  rdp_out_order_caps(STREAM s)
516          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
517          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
518          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
519          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 */
520          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
521          out_uint32_le(s, 0x4e4);        /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
522  }  }
# Line 385  rdp_out_order_caps(STREAM s) Line 525  rdp_out_order_caps(STREAM s)
525  static void  static void
526  rdp_out_bmpcache_caps(STREAM s)  rdp_out_bmpcache_caps(STREAM s)
527  {  {
528            int Bpp;
529          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
530          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
531    
532            Bpp = (g_server_bpp + 7) / 8;
533          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
534          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
535          out_uint16_le(s, 0x100);        /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
536          out_uint16_le(s, 0x12c);        /* entries */          out_uint16_le(s, 0x12c);        /* entries */
537          out_uint16_le(s, 0x400);        /* max cell size */          out_uint16_le(s, 0x400 * Bpp);  /* max cell size */
538          out_uint16_le(s, 0x106);        /* entries */          out_uint16_le(s, 0x106);        /* entries */
539          out_uint16_le(s, 0x1000);       /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
540    }
541    
542    /* Output bitmap cache v2 capability set */
543    static void
544    rdp_out_bmpcache2_caps(STREAM s)
545    {
546            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
547            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
548    
549            out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
550    
551            out_uint16_le(s, 0x0300);       /* flags? number of caches? */
552    
553            out_uint32_le(s, BMPCACHE2_C0_CELLS);
554            out_uint32_le(s, BMPCACHE2_C1_CELLS);
555            if (pstcache_init(2))
556            {
557                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
558            }
559            else
560            {
561                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
562            }
563            out_uint8s(s, 20);      /* other bitmap caches not used */
564  }  }
565    
566  /* Output control capability set */  /* Output control capability set */
# Line 456  rdp_out_colcache_caps(STREAM s) Line 622  rdp_out_colcache_caps(STREAM s)
622          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
623  }  }
624    
625  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
626          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
627          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
628          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
629          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
630          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
631          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
632          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
633          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
634          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
635          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
636          0x0C, 0x00, 0x08, 0x00, 0x01,          0x00, 0x00, 0x00, 0x00
         0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,  
         0x10, 0x00, 0x34, 0x00, 0xFE,  
         0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,  
         0xFE, 0x00, 0x08, 0x00, 0xFE,  
         0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,  
         0xFE, 0x00, 0x80, 0x00, 0xFE,  
         0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,  
         0x02, 0x00, 0x00, 0x00  
637  };  };
638    
639  /* Output unknown capability sets (number 13, 12, 14 and 16) */  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
640    
641    static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
642    
643    static uint8 caps_0x10[] = {
644            0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
645            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
646            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
647            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
648            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
649            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
650    };
651    
652    /* Output unknown capability sets */
653  static void  static void
654  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 * caps)
655  {  {
656          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
657          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
658    
659          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
660  }  }
661    
662  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 494  static void Line 665  static void
665  rdp_send_confirm_active(void)  rdp_send_confirm_active(void)
666  {  {
667          STREAM s;          STREAM s;
668          uint32 sec_flags = encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;          uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
669          uint16 caplen =          uint16 caplen =
670                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
671                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
672                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
673                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
674                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */  +
675                    4 /* w2k fix, why? */ ;
676    
677          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
678    
679          out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));          out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));
680          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
681          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
682    
683          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
684          out_uint16_le(s, 0x3ea);        /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
685          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
686          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
# Line 519  rdp_send_confirm_active(void) Line 692  rdp_send_confirm_active(void)
692          rdp_out_general_caps(s);          rdp_out_general_caps(s);
693          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
694          rdp_out_order_caps(s);          rdp_out_order_caps(s);
695          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
696          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
697          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
698          rdp_out_control_caps(s);          rdp_out_control_caps(s);
699          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
700          rdp_out_share_caps(s);          rdp_out_share_caps(s);
701          rdp_out_unknown_caps(s);  
702            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
703            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
704            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
705            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
706    
707          s_mark_end(s);          s_mark_end(s);
708          sec_send(s, sec_flags);          sec_send(s, sec_flags);
709  }  }
710    
711    /* Process a general capability set */
712    static void
713    rdp_process_general_caps(STREAM s)
714    {
715            uint16 pad2octetsB;     /* rdp5 flags? */
716    
717            in_uint8s(s, 10);
718            in_uint16_le(s, pad2octetsB);
719    
720            if (!pad2octetsB)
721                    g_use_rdp5 = False;
722    }
723    
724    /* Process a bitmap capability set */
725    static void
726    rdp_process_bitmap_caps(STREAM s)
727    {
728            uint16 width, height, bpp;
729    
730            in_uint16_le(s, bpp);
731            in_uint8s(s, 6);
732    
733            in_uint16_le(s, width);
734            in_uint16_le(s, height);
735    
736            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
737    
738            /*
739             * The server may limit bpp and change the size of the desktop (for
740             * example when shadowing another session).
741             */
742            if (g_server_bpp != bpp)
743            {
744                    warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);
745                    g_server_bpp = bpp;
746            }
747            if (g_width != width || g_height != height)
748            {
749                    warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
750                            width, height);
751                    g_width = width;
752                    g_height = height;
753                    ui_resize_window();
754            }
755    }
756    
757    /* Process server capabilities */
758    void
759    rdp_process_server_caps(STREAM s, uint16 length)
760    {
761            int n;
762            uint8 *next, *start;
763            uint16 ncapsets, capset_type, capset_length;
764    
765            start = s->p;
766    
767            in_uint16_le(s, ncapsets);
768            in_uint8s(s, 2);        /* pad */
769    
770            for (n = 0; n < ncapsets; n++)
771            {
772                    if (s->p > start + length)
773                            return;
774    
775                    in_uint16_le(s, capset_type);
776                    in_uint16_le(s, capset_length);
777    
778                    next = s->p + capset_length - 4;
779    
780                    switch (capset_type)
781                    {
782                            case RDP_CAPSET_GENERAL:
783                                    rdp_process_general_caps(s);
784                                    break;
785    
786                            case RDP_CAPSET_BITMAP:
787                                    rdp_process_bitmap_caps(s);
788                                    break;
789                    }
790    
791                    s->p = next;
792            }
793    }
794    
795  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
796  static void  static void
797  process_demand_active(STREAM s)  process_demand_active(STREAM s)
798  {  {
799          uint8 type;          uint8 type;
800            uint16 len_src_descriptor, len_combined_caps;
801    
802          in_uint32_le(s, rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
803            in_uint16_le(s, len_src_descriptor);
804            in_uint16_le(s, len_combined_caps);
805            in_uint8s(s, len_src_descriptor);
806    
807          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
808            rdp_process_server_caps(s, len_combined_caps);
809    
810          rdp_send_confirm_active();          rdp_send_confirm_active();
811          rdp_send_synchronise();          rdp_send_synchronise();
# Line 548  process_demand_active(STREAM s) Line 814  process_demand_active(STREAM s)
814          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
815          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
816          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
817          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();  
 }  
818    
819  /* Process a null system pointer PDU */          if (g_use_rdp5)
820  void          {
821  process_null_system_pointer_pdu(STREAM s)                  rdp_enum_bmpcache2();
822  {                  rdp_send_fonts(3);
823          // FIXME: We should probably set another cursor here,          }
824          // like the X window system base cursor or something.          else
825          ui_set_cursor(cache_get_cursor(0));          {
826                    rdp_send_fonts(1);
827                    rdp_send_fonts(2);
828            }
829    
830            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
831            reset_order_state();
832  }  }
833    
834  /* Process a colour pointer PDU */  /* Process a colour pointer PDU */
# Line 596  process_cached_pointer_pdu(STREAM s) Line 863  process_cached_pointer_pdu(STREAM s)
863          ui_set_cursor(cache_get_cursor(cache_idx));          ui_set_cursor(cache_get_cursor(cache_idx));
864  }  }
865    
866    /* Process a system pointer PDU */
867    void
868    process_system_pointer_pdu(STREAM s)
869    {
870            uint16 system_pointer_type;
871    
872            in_uint16(s, system_pointer_type);
873            switch (system_pointer_type)
874            {
875                    case RDP_NULL_POINTER:
876                            ui_set_null_cursor();
877                            break;
878    
879                    default:
880                            unimpl("System pointer message 0x%x\n", system_pointer_type);
881            }
882    }
883    
884  /* Process a pointer PDU */  /* Process a pointer PDU */
885  static void  static void
# Line 624  process_pointer_pdu(STREAM s) Line 908  process_pointer_pdu(STREAM s)
908                          process_cached_pointer_pdu(s);                          process_cached_pointer_pdu(s);
909                          break;                          break;
910    
911                    case RDP_POINTER_SYSTEM:
912                            process_system_pointer_pdu(s);
913                            break;
914    
915                  default:                  default:
916                          DEBUG(("Pointer message 0x%x\n", message_type));                          unimpl("Pointer message 0x%x\n", message_type);
917          }          }
918  }  }
919    
# Line 663  process_bitmap_updates(STREAM s) Line 951  process_bitmap_updates(STREAM s)
951                  if (!compress)                  if (!compress)
952                  {                  {
953                          int y;                          int y;
954                          bmpdata = xmalloc(width * height * Bpp);                          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
955                          for (y = 0; y < height; y++)                          for (y = 0; y < height; y++)
956                          {                          {
957                                  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 974  process_bitmap_updates(STREAM s)
974                          in_uint8s(s, 4);        /* line_size, final_size */                          in_uint8s(s, 4);        /* line_size, final_size */
975                  }                  }
976                  in_uint8p(s, data, size);                  in_uint8p(s, data, size);
977                  bmpdata = xmalloc(width * height * Bpp);                  bmpdata = (uint8 *) xmalloc(width * height * Bpp);
978                  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))                  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
979                  {                  {
980                          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 1001  process_palette(STREAM s)
1001          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
1002          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
1003    
1004          map.colours = xmalloc(3 * map.ncolours);          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
1005    
1006          DEBUG(("PALETTE(c=%d)\n", map.ncolours));          DEBUG(("PALETTE(c=%d)\n", map.ncolours));
1007    
# Line 739  process_update_pdu(STREAM s) Line 1027  process_update_pdu(STREAM s)
1027    
1028          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
1029    
1030            ui_begin_update();
1031          switch (update_type)          switch (update_type)
1032          {          {
1033                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 762  process_update_pdu(STREAM s) Line 1051  process_update_pdu(STREAM s)
1051                  default:                  default:
1052                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
1053          }          }
1054            ui_end_update();
1055    }
1056    
1057    /* Process a disconnect PDU */
1058    void
1059    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
1060    {
1061            in_uint32_le(s, *ext_disc_reason);
1062    
1063            DEBUG(("Received disconnect PDU\n"));
1064  }  }
1065    
1066  /* Process data PDU */  /* Process data PDU */
1067  static void  static BOOL
1068  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
1069  {  {
1070          uint8 data_pdu_type;          uint8 data_pdu_type;
1071            uint8 ctype;
1072            uint16 clen;
1073            uint32 len;
1074    
1075            uint32 roff, rlen;
1076    
1077          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          struct stream *ns = &(g_mppc_dict.ns);
1078    
1079            in_uint8s(s, 6);        /* shareid, pad, streamid */
1080            in_uint16(s, len);
1081          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
1082          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
1083            in_uint16(s, clen);
1084            clen -= 18;
1085    
1086            if (ctype & RDP_MPPC_COMPRESSED)
1087            {
1088                    if (len > RDP_MPPC_DICT_SIZE)
1089                      error("error decompressed packet size exceeds max\n");
1090                    if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1091                            error("error while decompressing packet\n");
1092    
1093                    //len -= 18;
1094    
1095                    /* allocate memory and copy the uncompressed data into the temporary stream */
1096                    ns->data = (uint8 *) xrealloc(ns->data, rlen);
1097    
1098                    memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
1099    
1100                    ns->size = rlen;
1101                    ns->end = (ns->data + ns->size);
1102                    ns->p = ns->data;
1103                    ns->rdp_hdr = ns->p;
1104    
1105                    s = ns;
1106            }
1107    
1108          switch (data_pdu_type)          switch (data_pdu_type)
1109          {          {
# Line 781  process_data_pdu(STREAM s) Line 1111  process_data_pdu(STREAM s)
1111                          process_update_pdu(s);                          process_update_pdu(s);
1112                          break;                          break;
1113    
1114                    case RDP_DATA_PDU_CONTROL:
1115                            DEBUG(("Received Control PDU\n"));
1116                            break;
1117    
1118                    case RDP_DATA_PDU_SYNCHRONISE:
1119                            DEBUG(("Received Sync PDU\n"));
1120                            break;
1121    
1122                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1123                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1124                          break;                          break;
# Line 794  process_data_pdu(STREAM s) Line 1132  process_data_pdu(STREAM s)
1132                          /* User logged on */                          /* User logged on */
1133                          break;                          break;
1134    
1135                    case RDP_DATA_PDU_DISCONNECT:
1136                            process_disconnect_pdu(s, ext_disc_reason);
1137                            return True;
1138    
1139                  default:                  default:
1140                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1141          }          }
1142            return False;
1143  }  }
1144    
1145  /* Process incoming packets */  /* Process incoming packets */
1146    /* nevers gets out of here till app is done */
1147  void  void
1148  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1149    {
1150            while (rdp_loop(deactivated, ext_disc_reason))
1151                    ;
1152    }
1153    
1154    /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1155    BOOL
1156    rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1157  {  {
1158          uint8 type;          uint8 type;
1159            BOOL disc = False;      /* True when a disconnect PDU was received */
1160            BOOL cont = True;
1161          STREAM s;          STREAM s;
1162    
1163          while ((s = rdp_recv(&type)) != NULL)          while (cont)
1164          {          {
1165                    s = rdp_recv(&type);
1166                    if (s == NULL)
1167                            return False;
1168                  switch (type)                  switch (type)
1169                  {                  {
1170                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1171                                  process_demand_active(s);                                  process_demand_active(s);
1172                                    *deactivated = False;
1173                                  break;                                  break;
   
1174                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1175                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
1176                                    *deactivated = True;
1177                                  break;                                  break;
   
1178                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1179                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1180                                  break;                                  break;
   
1181                          case 0:                          case 0:
1182                                  break;                                  break;
   
1183                          default:                          default:
1184                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1185                  }                  }
1186                    if (disc)
1187                            return False;
1188                    cont = g_next_packet < s->end;
1189          }          }
1190            return True;
1191  }  }
1192    
1193  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
# Line 835  BOOL Line 1195  BOOL
1195  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1196              char *command, char *directory)              char *command, char *directory)
1197  {  {
1198          if (!sec_connect(server, username))          if (!sec_connect(server, g_username))
1199                  return False;                  return False;
1200    
1201          rdp_send_logon_info(flags, domain, username, password, command, directory);          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1202          return True;          return True;
1203  }  }
1204    
Legend:
Removed from v.365  
changed lines
  Added in v.775
  ViewVC Help
Powered by ViewVC 1.1.26