/[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 725 by jsorg71, Sun Jun 27 17:51:54 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 43  rdp_recv(uint8 * type) Line 52  rdp_recv(uint8 * type)
52          static STREAM rdp_s;          static STREAM rdp_s;
53          uint16 length, pdu_type;          uint16 length, pdu_type;
54    
55          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
56          {          {
57                  rdp_s = sec_recv();                  rdp_s = sec_recv();
58                  if (rdp_s == NULL)                  if (rdp_s == NULL)
59                          return NULL;                          return NULL;
60    
61                  next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
62          }          }
63          else          else
64          {          {
65                  rdp_s->p = next_packet;                  rdp_s->p = g_next_packet;
66          }          }
67    
68          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
69          /* 32k packets are really 8, keepalive fix */          /* 32k packets are really 8, keepalive fix */
70          if (length == 0x8000)          if (length == 0x8000)
71          {          {
72                  next_packet += 8;                  g_next_packet += 8;
73                  *type = 0;                  *type = 0;
74                  return rdp_s;                  return rdp_s;
75          }          }
# Line 69  rdp_recv(uint8 * type) Line 78  rdp_recv(uint8 * type)
78          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
79    
80  #if WITH_DEBUG  #if WITH_DEBUG
81          DEBUG(("RDP packet #%d, (type %x)\n", ++packetno, *type));          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
82          //      hexdump(next_packet, length);          hexdump(g_next_packet, length);
83  #endif /*  */  #endif /*  */
84    
85          next_packet += length;          g_next_packet += length;
86          return rdp_s;          return rdp_s;
87  }  }
88    
# Line 83  rdp_init_data(int maxlen) Line 92  rdp_init_data(int maxlen)
92  {  {
93          STREAM s;          STREAM s;
94    
95          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
96          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
97    
98          return s;          return s;
# Line 100  rdp_send_data(STREAM s, uint8 data_pdu_t Line 109  rdp_send_data(STREAM s, uint8 data_pdu_t
109    
110          out_uint16_le(s, length);          out_uint16_le(s, length);
111          out_uint16_le(s, (RDP_PDU_DATA | 0x10));          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
112          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
113    
114          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
115          out_uint8(s, 0);        /* pad */          out_uint8(s, 0);        /* pad */
116          out_uint8(s, 1);        /* streamid */          out_uint8(s, 1);        /* streamid */
117          out_uint16_le(s, (length - 14));          out_uint16_le(s, (length - 14));
# Line 110  rdp_send_data(STREAM s, uint8 data_pdu_t Line 119  rdp_send_data(STREAM s, uint8 data_pdu_t
119          out_uint8(s, 0);        /* compress_type */          out_uint8(s, 0);        /* compress_type */
120          out_uint16(s, 0);       /* compress_len */          out_uint16(s, 0);       /* compress_len */
121    
122          sec_send(s, encryption ? SEC_ENCRYPT : 0);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
123  }  }
124    
125  /* Output a string in Unicode */  /* Output a string in Unicode */
# Line 130  rdp_out_unistr(STREAM s, char *string, i Line 139  rdp_out_unistr(STREAM s, char *string, i
139          s->p += len;          s->p += len;
140  }  }
141    
142    /* Input a string in Unicode
143     *
144     * Returns str_len of string
145     */
146    int
147    rdp_in_unistr(STREAM s, char *string, int uni_len)
148    {
149            int i = 0;
150    
151            while (i < uni_len / 2)
152            {
153                    in_uint8a(s, &string[i++], 1);
154                    in_uint8s(s, 1);
155            }
156    
157            return i - 1;
158    }
159    
160    
161  /* Parse a logon info packet */  /* Parse a logon info packet */
162  static void  static void
163  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
164                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
165  {  {
166            char *ipaddr = tcp_get_address();
167          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
168          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
169          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
170          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
171          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
172          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;          int len_ip = 2 * strlen(ipaddr);
173            int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
174            int packetlen = 0;
175            uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
176          STREAM s;          STREAM s;
177            time_t t = time(NULL);
178            time_t tzone;
179    
180          if (1 == server_rdp_version)  #if 0
181            /* enable rdp compression */
182            /* some problems still exist with rdp5 */
183            flags |= RDP_COMPRESSION;
184    #endif
185    
186            if (!g_use_rdp5 || 1 == g_server_rdp_version)
187          {          {
188                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
189    
# Line 165  rdp_send_logon_info(uint32 flags, char * Line 205  rdp_send_logon_info(uint32 flags, char *
205          }          }
206          else          else
207          {          {
208    
209                    flags |= RDP_LOGON_BLOB;
210                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
211                  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 */
212                            4 +     /* flags */
213                            2 +     /* len_domain */
214                            2 +     /* len_user */
215                            (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
216                            (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
217                            2 +     /* len_program */
218                            2 +     /* len_directory */
219                            (0 < len_domain ? len_domain : 2) +     /* domain */
220                            len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
221                            (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
222                            (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
223                            2 +     /* Client ip length */
224                            len_ip +        /* Client ip */
225                            2 +     /* DLL string length */
226                            len_dll +       /* DLL string */
227                            2 +     /* Unknown */
228                            2 +     /* Unknown */
229                            64 +    /* Time zone #0 */
230                            2 +     /* Unknown */
231                            64 +    /* Time zone #1 */
232                            32;     /* Unknown */
233    
234                  out_uint32(s, 0);                  s = sec_init(sec_flags, packetlen);
235                    DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
236    
237                    out_uint32(s, 0);       /* Unknown */
238                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
239                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
240                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
241                  if (flags & RDP_LOGON_AUTO)                  if (flags & RDP_LOGON_AUTO)
242                  {                  {
243                          out_uint16_le(s, len_password);                          out_uint16_le(s, len_password);
244    
245                    }
246                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
247                    {
248                            out_uint16_le(s, 0);
249                  }                  }
                 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 */  
250                  out_uint16_le(s, len_program);                  out_uint16_le(s, len_program);
251                  out_uint16_le(s, len_directory);                  out_uint16_le(s, len_directory);
252                    if (0 < len_domain)
253                            rdp_out_unistr(s, domain, len_domain);
254                    else
255                            out_uint16_le(s, 0);
256                    rdp_out_unistr(s, user, len_user);
257                  if (flags & RDP_LOGON_AUTO)                  if (flags & RDP_LOGON_AUTO)
258                  {                  {
259                          rdp_out_unistr(s, password, len_password);                          rdp_out_unistr(s, password, len_password);
260                  }                  }
261                  rdp_out_unistr(s, domain, len_domain);                  if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
262                  rdp_out_unistr(s, user, len_user);                  {
263                  out_uint16(s, 0);                          out_uint16_le(s, 0);
264                  out_uint16(s, 0);                  }
265                  if (0 < len_program)                  if (0 < len_program)
266                    {
267                          rdp_out_unistr(s, program, len_program);                          rdp_out_unistr(s, program, len_program);
268    
269                    }
270                    else
271                    {
272                            out_uint16_le(s, 0);
273                    }
274                  if (0 < len_directory)                  if (0 < len_directory)
275                    {
276                          rdp_out_unistr(s, directory, len_directory);                          rdp_out_unistr(s, directory, len_directory);
277                  out_uint8s(s, 30);      /* Some kind of client data - let's see if the server                  }
278                                             handles zeros well.. */                  else
279                  out_uint16_le(s, 60);                  {
280                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", 58);                          out_uint16_le(s, 0);
281                  out_uint32_be(s, 0x88ffffff);                  }
282                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid") - 2);                  out_uint16_le(s, 2);
283                  out_uint8s(s, 30 - 2 * strlen("GTP, normaltid"));                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
284                    rdp_out_unistr(s, ipaddr, len_ip);
285                    out_uint16_le(s, len_dll + 2);
286                    rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
287    
288                    tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
289                    out_uint32_le(s, tzone);
290    
291                    rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
292                    out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
293    
294                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
295                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
296                  out_uint32_le(s, 2);                  out_uint32_le(s, 3);
297                  out_uint32(s, 0);                  out_uint32_le(s, 0);
298                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0);
                 out_uint32_le(s, 0xfffffffe);  
                 out_uint32_le(s, 0x0f);  
                 out_uint32(s, 0);  
299    
300                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid") - 1);                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid"));
301                  out_uint8s(s, 30 - 2 * strlen("GTP, sommartid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, sommartid"));
302    
303                  out_uint32_le(s, 0x030000);                  out_uint32_le(s, 0x30000);
304                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
305                  out_uint32_le(s, 2);                  out_uint32_le(s, 2);
306                  out_uint32(s, 0);                  out_uint32(s, 0);
307                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
308                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
309                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
310                  out_uint32(s, 0);                  out_uint32(s, 0);
311    
312    
313          }          }
314          s_mark_end(s);          s_mark_end(s);
315          sec_send(s, sec_flags);          sec_send(s, sec_flags);
# Line 279  rdp_send_input(uint32 time, uint16 messa Line 367  rdp_send_input(uint32 time, uint16 messa
367          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
368  }  }
369    
370    /* Inform the server on the contents of the persistent bitmap cache */
371    static void
372    rdp_enum_bmpcache2(void)
373    {
374            STREAM s;
375            uint8 idlist[BMPCACHE2_NUM_PSTCELLS * sizeof(BITMAP_ID)];
376            uint32 nids, offset, count, flags;
377    
378            offset = 0;
379            nids = pstcache_enumerate(2, idlist);
380    
381            while (offset < nids)
382            {
383                    count = MIN(nids - offset, 169);
384    
385                    s = rdp_init_data(24 + count * sizeof(BITMAP_ID));
386    
387                    flags = 0;
388                    if (offset == 0)
389                            flags |= PDU_FLAG_FIRST;
390                    if (nids - offset <= 169)
391                            flags |= PDU_FLAG_LAST;
392    
393                    /* header */
394                    out_uint32_le(s, 0);
395                    out_uint16_le(s, count);
396                    out_uint16_le(s, 0);
397                    out_uint16_le(s, 0);
398                    out_uint16_le(s, 0);
399                    out_uint16_le(s, 0);
400                    out_uint16_le(s, nids);
401                    out_uint32_le(s, 0);
402                    out_uint32_le(s, flags);
403    
404                    /* list */
405                    out_uint8a(s, idlist + offset * sizeof(BITMAP_ID),
406                                    count * sizeof(BITMAP_ID));
407    
408                    s_mark_end(s);
409                    rdp_send_data(s, 0x2b);
410    
411                    offset += 169;
412            }
413    }
414    
415  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
416  static void  static void
417  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 288  rdp_send_fonts(uint16 seq) Line 421  rdp_send_fonts(uint16 seq)
421          s = rdp_init_data(8);          s = rdp_init_data(8);
422    
423          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
424          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
425          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
426          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
427    
# Line 308  rdp_out_general_caps(STREAM s) Line 441  rdp_out_general_caps(STREAM s)
441          out_uint16_le(s, 0x200);        /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
442          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
443          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
444          out_uint16_le(s, use_rdp5 ? 0x40d : 0);          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
445          /* Pad, according to T.128. 0x40d seems to          /* Pad, according to T.128. 0x40d seems to
446             trigger             trigger
447             the server to start sending RDP5 packets.             the server to start sending RDP5 packets.
# Line 329  rdp_out_bitmap_caps(STREAM s) Line 462  rdp_out_bitmap_caps(STREAM s)
462          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
463          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
464    
465          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
466          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
467          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
468          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
469          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
470          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
471          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
472          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
473          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
474          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
475          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
476          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
# Line 354  rdp_out_order_caps(STREAM s) Line 487  rdp_out_order_caps(STREAM s)
487          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
488          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
489          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
490          order_caps[3] = 1;      /* required for memblt? */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
491          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
492          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
493          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
494          order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
495          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
496          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
497          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
# Line 376  rdp_out_order_caps(STREAM s) Line 509  rdp_out_order_caps(STREAM s)
509          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
510          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
511          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
512          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 */
513          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
514          out_uint32_le(s, 0x4e4);        /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
515  }  }
# Line 385  rdp_out_order_caps(STREAM s) Line 518  rdp_out_order_caps(STREAM s)
518  static void  static void
519  rdp_out_bmpcache_caps(STREAM s)  rdp_out_bmpcache_caps(STREAM s)
520  {  {
521            int Bpp;
522          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
523          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
524    
525            Bpp = (g_server_bpp + 7) / 8;
526          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
527          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
528          out_uint16_le(s, 0x100);        /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
529          out_uint16_le(s, 0x12c);        /* entries */          out_uint16_le(s, 0x12c);        /* entries */
530          out_uint16_le(s, 0x400);        /* max cell size */          out_uint16_le(s, 0x400 * Bpp);  /* max cell size */
531          out_uint16_le(s, 0x106);        /* entries */          out_uint16_le(s, 0x106);        /* entries */
532          out_uint16_le(s, 0x1000);       /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
533    }
534    
535    /* Output bitmap cache v2 capability set */
536    static void
537    rdp_out_bmpcache2_caps(STREAM s)
538    {
539            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
540            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
541    
542            out_uint16_le(s, g_bitmap_cache_persist_enable ? 1 : 0);        /* version */
543    
544            out_uint16_le(s, 0x0300);       /* flags? number of caches? */
545    
546            out_uint32_le(s, BMPCACHE2_C0_CELLS);
547            out_uint32_le(s, BMPCACHE2_C1_CELLS);
548            if (pstcache_init(2))
549            {
550                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
551            }
552            else
553            {
554                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
555            }
556            out_uint8s(s, 20);              /* other bitmap caches not used */
557  }  }
558    
559  /* Output control capability set */  /* Output control capability set */
# Line 456  rdp_out_colcache_caps(STREAM s) Line 615  rdp_out_colcache_caps(STREAM s)
615          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
616  }  }
617    
618  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
619          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
620          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
621          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
622          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
623          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
624          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
625          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
626          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
627          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
628          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
629          0x0C, 0x00, 0x08, 0x00, 0x01,          0x00, 0x00, 0x00, 0x00
630          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,  };
631          0x10, 0x00, 0x34, 0x00, 0xFE,  
632          0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
633          0xFE, 0x00, 0x08, 0x00, 0xFE,  
634          0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,  static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
635          0xFE, 0x00, 0x80, 0x00, 0xFE,  
636          0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,  static uint8 caps_0x10[] = {
637          0x02, 0x00, 0x00, 0x00          0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
638            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
639            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
640            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
641            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
642            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
643  };  };
644    
645  /* Output unknown capability sets (number 13, 12, 14 and 16) */  /* Output unknown capability sets */
646  static void  static void
647  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 *caps)
648  {  {
649          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
650          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
651    
652          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
653  }  }
654    
655  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 494  static void Line 658  static void
658  rdp_send_confirm_active(void)  rdp_send_confirm_active(void)
659  {  {
660          STREAM s;          STREAM s;
661          uint32 sec_flags = encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;          uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
662          uint16 caplen =          uint16 caplen =
663                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
664                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
665                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
666                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
667                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */ +
668                    4 /* w2k fix, why? */ ;
669    
670          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
671    
672          out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));          out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));
673          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
674          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
675    
676          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
677          out_uint16_le(s, 0x3ea);        /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
678          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
679          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
# Line 519  rdp_send_confirm_active(void) Line 685  rdp_send_confirm_active(void)
685          rdp_out_general_caps(s);          rdp_out_general_caps(s);
686          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
687          rdp_out_order_caps(s);          rdp_out_order_caps(s);
688          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
689          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
690          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
691          rdp_out_control_caps(s);          rdp_out_control_caps(s);
692          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
693          rdp_out_share_caps(s);          rdp_out_share_caps(s);
         rdp_out_unknown_caps(s);  
694    
695            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
696            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
697            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
698            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
699                                    
700          s_mark_end(s);          s_mark_end(s);
701          sec_send(s, sec_flags);          sec_send(s, sec_flags);
702  }  }
703    
704    /* Process a general capability set */
705    static void
706    rdp_process_general_caps(STREAM s)
707    {
708            uint16 pad2octetsB;     /* rdp5 flags? */
709    
710            in_uint8s(s, 10);
711            in_uint16_le(s, pad2octetsB);
712    
713            if (!pad2octetsB)
714                    g_use_rdp5 = False;
715    }
716    
717    /* Process a bitmap capability set */
718    static void
719    rdp_process_bitmap_caps(STREAM s)
720    {
721            uint16 width, height, bpp;
722    
723            in_uint16_le(s, bpp);
724            in_uint8s(s, 6);
725    
726            in_uint16_le(s, width);
727            in_uint16_le(s, height);
728    
729            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
730    
731            /*
732             * The server may limit bpp and change the size of the desktop (for
733             * example when shadowing another session).
734             */
735            if (g_server_bpp != bpp)
736            {
737                    warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);
738                    g_server_bpp = bpp;
739            }
740            if (g_width != width || g_height != height)
741            {
742                    warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
743                                    width, height);
744                    g_width = width;
745                    g_height = height;
746                    ui_resize_window();
747            }
748    }
749    
750    /* Process server capabilities */
751    void
752    rdp_process_server_caps(STREAM s, uint16 length)
753    {
754            int n;
755            uint8 *next, *start;
756            uint16 ncapsets, capset_type, capset_length;
757    
758            start = s->p;
759    
760            in_uint16_le(s, ncapsets);
761            in_uint8s(s, 2);        /* pad */
762    
763            for (n = 0; n < ncapsets; n++)
764            {
765                    if (s->p > start + length)
766                            return;
767    
768                    in_uint16_le(s, capset_type);
769                    in_uint16_le(s, capset_length);
770    
771                    next = s->p + capset_length - 4;
772    
773                    switch (capset_type)
774                    {
775                            case RDP_CAPSET_GENERAL:
776                                    rdp_process_general_caps(s);
777                                    break;
778    
779                            case RDP_CAPSET_BITMAP:
780                                    rdp_process_bitmap_caps(s);
781                                    break;
782                    }
783    
784                    s->p = next;
785            }
786    }
787    
788  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
789  static void  static void
790  process_demand_active(STREAM s)  process_demand_active(STREAM s)
791  {  {
792          uint8 type;          uint8 type;
793            uint16 len_src_descriptor, len_combined_caps;
794    
795          in_uint32_le(s, rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
796            in_uint16_le(s, len_src_descriptor);
797            in_uint16_le(s, len_combined_caps);
798            in_uint8s(s, len_src_descriptor);
799    
800          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
801            rdp_process_server_caps(s, len_combined_caps);
802    
803          rdp_send_confirm_active();          rdp_send_confirm_active();
804          rdp_send_synchronise();          rdp_send_synchronise();
# Line 548  process_demand_active(STREAM s) Line 807  process_demand_active(STREAM s)
807          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
808          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
809          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
810          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();  
 }  
811    
812  /* Process a null system pointer PDU */          if (g_use_rdp5)
813  void          {
814  process_null_system_pointer_pdu(STREAM s)                  rdp_enum_bmpcache2();
815  {                  rdp_send_fonts(3);
816          // FIXME: We should probably set another cursor here,          }
817          // like the X window system base cursor or something.          else
818          ui_set_cursor(cache_get_cursor(0));          {
819                    rdp_send_fonts(1);
820                    rdp_send_fonts(2);
821            }
822    
823            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
824            reset_order_state();
825  }  }
826    
827  /* Process a colour pointer PDU */  /* Process a colour pointer PDU */
# Line 596  process_cached_pointer_pdu(STREAM s) Line 856  process_cached_pointer_pdu(STREAM s)
856          ui_set_cursor(cache_get_cursor(cache_idx));          ui_set_cursor(cache_get_cursor(cache_idx));
857  }  }
858    
859    /* Process a system pointer PDU */
860    void
861    process_system_pointer_pdu(STREAM s)
862    {
863            uint16 system_pointer_type;
864    
865            in_uint16(s, system_pointer_type);
866            switch (system_pointer_type)
867            {
868                    case RDP_NULL_POINTER:
869                            ui_set_null_cursor();
870                            break;
871    
872                    default:
873                            unimpl("System pointer message 0x%x\n", system_pointer_type);
874            }
875    }
876    
877  /* Process a pointer PDU */  /* Process a pointer PDU */
878  static void  static void
# Line 624  process_pointer_pdu(STREAM s) Line 901  process_pointer_pdu(STREAM s)
901                          process_cached_pointer_pdu(s);                          process_cached_pointer_pdu(s);
902                          break;                          break;
903    
904                    case RDP_POINTER_SYSTEM:
905                            process_system_pointer_pdu(s);
906                            break;
907    
908                  default:                  default:
909                          DEBUG(("Pointer message 0x%x\n", message_type));                          unimpl("Pointer message 0x%x\n", message_type);
910          }          }
911  }  }
912    
# Line 663  process_bitmap_updates(STREAM s) Line 944  process_bitmap_updates(STREAM s)
944                  if (!compress)                  if (!compress)
945                  {                  {
946                          int y;                          int y;
947                          bmpdata = xmalloc(width * height * Bpp);                          bmpdata = (uint8 *) xmalloc(width * height * Bpp);
948                          for (y = 0; y < height; y++)                          for (y = 0; y < height; y++)
949                          {                          {
950                                  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 967  process_bitmap_updates(STREAM s)
967                          in_uint8s(s, 4);        /* line_size, final_size */                          in_uint8s(s, 4);        /* line_size, final_size */
968                  }                  }
969                  in_uint8p(s, data, size);                  in_uint8p(s, data, size);
970                  bmpdata = xmalloc(width * height * Bpp);                  bmpdata = (uint8 *) xmalloc(width * height * Bpp);
971                  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))                  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
972                  {                  {
973                          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 994  process_palette(STREAM s)
994          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
995          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
996    
997          map.colours = xmalloc(3 * map.ncolours);          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
998    
999          DEBUG(("PALETTE(c=%d)\n", map.ncolours));          DEBUG(("PALETTE(c=%d)\n", map.ncolours));
1000    
# Line 739  process_update_pdu(STREAM s) Line 1020  process_update_pdu(STREAM s)
1020    
1021          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
1022    
1023            ui_begin_update();
1024          switch (update_type)          switch (update_type)
1025          {          {
1026                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 762  process_update_pdu(STREAM s) Line 1044  process_update_pdu(STREAM s)
1044                  default:                  default:
1045                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
1046          }          }
1047            ui_end_update();
1048    }
1049    
1050    /* Process a disconnect PDU */
1051    void
1052    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
1053    {
1054            in_uint32_le(s, *ext_disc_reason);
1055    
1056            DEBUG(("Received disconnect PDU\n"));
1057  }  }
1058    
1059  /* Process data PDU */  /* Process data PDU */
1060  static void  static BOOL
1061  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
1062  {  {
1063          uint8 data_pdu_type;          uint8 data_pdu_type;
1064            uint8 ctype;
1065            uint16 clen;
1066            uint32 len;
1067    
1068          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          uint32 roff, rlen;
1069    
1070            struct stream *ns = &(g_mppc_dict.ns);
1071    
1072            in_uint8s(s, 6);        /* shareid, pad, streamid */
1073            in_uint16(s, len);
1074          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
1075          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
1076            in_uint16(s, clen);
1077            clen -= 18;
1078    
1079            if (ctype & RDP_MPPC_COMPRESSED)
1080            {
1081    
1082                    if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1083                            error("error while decompressing packet\n");
1084    
1085                    //len -= 18;
1086    
1087                    /* allocate memory and copy the uncompressed data into the temporary stream */
1088                    ns->data = (uint8 *) xrealloc(ns->data, rlen);
1089    
1090                    memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
1091    
1092                    ns->size = rlen;
1093                    ns->end = (ns->data + ns->size);
1094                    ns->p = ns->data;
1095                    ns->rdp_hdr = ns->p;
1096    
1097                    s = ns;
1098            }
1099    
1100          switch (data_pdu_type)          switch (data_pdu_type)
1101          {          {
# Line 781  process_data_pdu(STREAM s) Line 1103  process_data_pdu(STREAM s)
1103                          process_update_pdu(s);                          process_update_pdu(s);
1104                          break;                          break;
1105    
1106                    case RDP_DATA_PDU_CONTROL:
1107                            DEBUG(("Received Control PDU\n"));
1108                            break;
1109    
1110                    case RDP_DATA_PDU_SYNCHRONISE:
1111                            DEBUG(("Received Sync PDU\n"));
1112                            break;
1113    
1114                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1115                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1116                          break;                          break;
# Line 794  process_data_pdu(STREAM s) Line 1124  process_data_pdu(STREAM s)
1124                          /* User logged on */                          /* User logged on */
1125                          break;                          break;
1126    
1127                    case RDP_DATA_PDU_DISCONNECT:
1128                            process_disconnect_pdu(s, ext_disc_reason);
1129                            return True;
1130    
1131                  default:                  default:
1132                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1133          }          }
1134            return False;
1135  }  }
1136    
1137  /* Process incoming packets */  /* Process incoming packets */
1138  void  void
1139  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1140  {  {
1141          uint8 type;          uint8 type;
1142            BOOL disc = False;      /* True when a disconnect PDU was received */
1143          STREAM s;          STREAM s;
1144    
1145          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 812  rdp_main_loop(void) Line 1148  rdp_main_loop(void)
1148                  {                  {
1149                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1150                                  process_demand_active(s);                                  process_demand_active(s);
1151                                    *deactivated = False;
1152                                  break;                                  break;
1153    
1154                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1155                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
1156                                    *deactivated = True;
1157                                  break;                                  break;
1158    
1159                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1160                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1161                                  break;                                  break;
1162    
1163                          case 0:                          case 0:
# Line 827  rdp_main_loop(void) Line 1166  rdp_main_loop(void)
1166                          default:                          default:
1167                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1168                  }                  }
1169    
1170                    if (disc)
1171                    {
1172                            return;
1173                    }
1174            }
1175            return;
1176    }
1177    
1178    /* used in uiports, processes the rdp packets waiting */
1179    BOOL
1180    rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1181    {
1182            uint8 type;
1183            BOOL disc = False;      /* True when a disconnect PDU was received */
1184            BOOL cont = True;
1185            STREAM s;
1186    
1187            while (cont)
1188            {
1189                    s = rdp_recv(&type);
1190                    if (s == NULL)
1191                            return False;
1192                    switch (type)
1193                    {
1194                            case RDP_PDU_DEMAND_ACTIVE:
1195                                    process_demand_active(s);
1196                                    *deactivated = False;
1197                                    break;
1198                            case RDP_PDU_DEACTIVATE:
1199                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
1200                                    *deactivated = True;
1201                                    break;
1202                            case RDP_PDU_DATA:
1203                                    disc = process_data_pdu(s, ext_disc_reason);
1204                                    break;
1205                            case 0:
1206                                    break;
1207                            default:
1208                                    unimpl("PDU %d\n", type);
1209                    }
1210                    if (disc)
1211                            return False;
1212                    cont = g_next_packet < s->end;
1213          }          }
1214            return True;
1215  }  }
1216    
1217  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
# Line 835  BOOL Line 1219  BOOL
1219  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1220              char *command, char *directory)              char *command, char *directory)
1221  {  {
1222          if (!sec_connect(server, username))          if (!sec_connect(server, g_username))
1223                  return False;                  return False;
1224    
1225          rdp_send_logon_info(flags, domain, username, password, command, directory);          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1226          return True;          return True;
1227  }  }
1228    
Legend:
Removed from v.365  
changed lines
  Added in v.725
  ViewVC Help
Powered by ViewVC 1.1.26