/[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 10 by matty, Tue Aug 15 10:23:24 2000 UTC revision 283 by jsorg71, Tue Dec 10 17:24:27 2002 UTC
# Line 1  Line 1 
1  /*  /*
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     Protocol services - RDP layer     Protocol services - RDP layer
4     Copyright (C) Matthew Chapman 1999-2000     Copyright (C) Matthew Chapman 1999-2002
5        
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
# Line 22  Line 22 
22    
23  extern uint16 mcs_userid;  extern uint16 mcs_userid;
24  extern char username[16];  extern char username[16];
25    extern BOOL bitmap_compression;
26  extern BOOL orders;  extern BOOL orders;
27    extern BOOL encryption;
28    extern BOOL desktop_save;
29    
30  unsigned char *next_packet;  uint8 *next_packet;
31  uint32 rdp_shareid;  uint32 rdp_shareid;
32    
33  /* Initialise an RDP packet */  /* Initialise an RDP packet */
34  static STREAM rdp_init(int maxlen)  static STREAM
35    rdp_init(int maxlen)
36  {  {
37          STREAM s;          STREAM s;
38    
39          s = sec_init(SEC_ENCRYPT, maxlen + 6);          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 6);
40          s_push_layer(s, rdp_hdr, 6);          s_push_layer(s, rdp_hdr, 6);
41    
42          return s;          return s;
43  }  }
44    
45  /* Send an RDP packet */  /* Send an RDP packet */
46  static void rdp_send(STREAM s, uint8 pdu_type)  static void
47    rdp_send(STREAM s, uint8 pdu_type)
48  {  {
49          uint16 length;          uint16 length;
50    
# Line 47  static void rdp_send(STREAM s, uint8 pdu Line 52  static void rdp_send(STREAM s, uint8 pdu
52          length = s->end - s->p;          length = s->end - s->p;
53    
54          out_uint16_le(s, length);          out_uint16_le(s, length);
55          out_uint16_le(s, (pdu_type | 0x10)); /* Version 1 */          out_uint16_le(s, (pdu_type | 0x10));    /* Version 1 */
56          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (mcs_userid + 1001));
57    
58          sec_send(s, SEC_ENCRYPT);          sec_send(s, encryption ? SEC_ENCRYPT : 0);
59  }  }
60    
61  /* Receive an RDP packet */  /* Receive an RDP packet */
62  static STREAM rdp_recv(uint8 *type)  static STREAM
63    rdp_recv(uint8 * type)
64  {  {
65          static STREAM rdp_s;          static STREAM rdp_s;
66          uint16 length, pdu_type;          uint16 length, pdu_type;
# Line 73  static STREAM rdp_recv(uint8 *type) Line 79  static STREAM rdp_recv(uint8 *type)
79          }          }
80    
81          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
82            /* 32k packets are really 8, keepalive fix */
83            if (length == 0x8000)
84            {
85                    next_packet += 8;
86                    *type = 0;
87                    return rdp_s;
88            }
89          in_uint16_le(rdp_s, pdu_type);          in_uint16_le(rdp_s, pdu_type);
90          in_uint8s(rdp_s, 2); /* userid */          in_uint8s(rdp_s, 2);    /* userid */
   
         next_packet += length;  
91          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
92    
93  #if RDP_DEBUG  #if WITH_DEBUG
94          DEBUG("RDP packet (type %x):\n", *type);          DEBUG(("RDP packet (type %x):\n", *type));
95          hexdump(rdp_s->p, length);          hexdump(next_packet, length);
96  #endif  #endif /*  */
97    
98            next_packet += length;
99          return rdp_s;          return rdp_s;
100  }  }
101    
102  /* Initialise an RDP data packet */  /* Initialise an RDP data packet */
103  static STREAM rdp_init_data(int maxlen)  static STREAM
104    rdp_init_data(int maxlen)
105  {  {
106          STREAM s;          STREAM s;
107    
108          s = sec_init(SEC_ENCRYPT, maxlen + 18);          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);
109          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
110    
111          return s;          return s;
112  }  }
113    
114  /* Send an RDP data packet */  /* Send an RDP data packet */
115  static void rdp_send_data(STREAM s, uint8 data_pdu_type)  static void
116    rdp_send_data(STREAM s, uint8 data_pdu_type)
117  {  {
118          uint16 length;          uint16 length;
119    
# Line 111  static void rdp_send_data(STREAM s, uint Line 125  static void rdp_send_data(STREAM s, uint
125          out_uint16_le(s, (mcs_userid + 1001));          out_uint16_le(s, (mcs_userid + 1001));
126    
127          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, rdp_shareid);
128          out_uint8(s, 0);  /* pad */          out_uint8(s, 0);        /* pad */
129          out_uint8(s, 1);  /* streamid */          out_uint8(s, 1);        /* streamid */
130          out_uint16(s, (length - 14));          out_uint16_le(s, (length - 14));
131          out_uint8(s, data_pdu_type);          out_uint8(s, data_pdu_type);
132          out_uint8(s, 0);  /* compress_type */          out_uint8(s, 0);        /* compress_type */
133          out_uint16(s, 0); /* compress_len */          out_uint16(s, 0);       /* compress_len */
134    
135          sec_send(s, SEC_ENCRYPT);          sec_send(s, encryption ? SEC_ENCRYPT : 0);
136  }  }
137    
138  /* Output a string in Unicode */  /* Output a string in Unicode */
139  void rdp_out_unistr(STREAM s, char *string, int len)  void
140    rdp_out_unistr(STREAM s, char *string, int len)
141  {  {
142          int i = 0, j = 0;          int i = 0, j = 0;
143    
# Line 138  void rdp_out_unistr(STREAM s, char *stri Line 153  void rdp_out_unistr(STREAM s, char *stri
153  }  }
154    
155  /* Parse a logon info packet */  /* Parse a logon info packet */
156  static void rdp_send_logon_info(uint32 flags, char *domain, char *user,  static void
157                                  char *password, char *program, char *directory)  rdp_send_logon_info(uint32 flags, char *domain, char *user,
158  {                      char *password, char *program, char *directory)
159          int len_domain    = 2 * strlen(domain);  {
160          int len_user      = 2 * strlen(user);          int len_domain = 2 * strlen(domain);
161          int len_password  = 2 * strlen(password);          int len_user = 2 * strlen(user);
162          int len_program   = 2 * strlen(program);          int len_password = 2 * strlen(password);
163            int len_program = 2 * strlen(program);
164          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
165          uint32 sec_flags = SEC_LOGON_INFO | SEC_ENCRYPT;          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
166          STREAM s;          STREAM s;
167    
168          s = sec_init(sec_flags, 18 + len_domain + len_user + len_password          s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
169                                          + len_program + len_directory + 10);                       + len_program + len_directory + 10);
170    
171          out_uint32(s, 0);          out_uint32(s, 0);
172          out_uint32_le(s, flags);          out_uint32_le(s, flags);
# Line 159  static void rdp_send_logon_info(uint32 f Line 175  static void rdp_send_logon_info(uint32 f
175          out_uint16_le(s, len_password);          out_uint16_le(s, len_password);
176          out_uint16_le(s, len_program);          out_uint16_le(s, len_program);
177          out_uint16_le(s, len_directory);          out_uint16_le(s, len_directory);
178          rdp_out_unistr(s, domain,    len_domain);          rdp_out_unistr(s, domain, len_domain);
179          rdp_out_unistr(s, user,      len_user);          rdp_out_unistr(s, user, len_user);
180          rdp_out_unistr(s, password,  len_password);          rdp_out_unistr(s, password, len_password);
181          rdp_out_unistr(s, program,   len_program);          rdp_out_unistr(s, program, len_program);
182          rdp_out_unistr(s, directory, len_directory);          rdp_out_unistr(s, directory, len_directory);
183    
184          s_mark_end(s);          s_mark_end(s);
# Line 170  static void rdp_send_logon_info(uint32 f Line 186  static void rdp_send_logon_info(uint32 f
186  }  }
187    
188  /* Send a control PDU */  /* Send a control PDU */
189  static void rdp_send_control(uint16 action)  static void
190    rdp_send_control(uint16 action)
191  {  {
192          STREAM s;          STREAM s;
193    
194          s = rdp_init_data(8);          s = rdp_init_data(8);
195    
196          out_uint16_le(s, action);          out_uint16_le(s, action);
197          out_uint16(s, 0); /* userid */          out_uint16(s, 0);       /* userid */
198          out_uint32(s, 0); /* control id */          out_uint32(s, 0);       /* control id */
199    
200          s_mark_end(s);          s_mark_end(s);
201          rdp_send_data(s, RDP_DATA_PDU_CONTROL);          rdp_send_data(s, RDP_DATA_PDU_CONTROL);
202  }  }
203    
204  /* Send a synchronisation PDU */  /* Send a synchronisation PDU */
205  static void rdp_send_synchronise()  static void
206    rdp_send_synchronise(void)
207  {  {
208          STREAM s;          STREAM s;
209    
210          s = rdp_init_data(4);          s = rdp_init_data(4);
211    
212          out_uint16_le(s, 1); /* type */          out_uint16_le(s, 1);    /* type */
213          out_uint16_le(s, 1002);          out_uint16_le(s, 1002);
214    
215          s_mark_end(s);          s_mark_end(s);
# Line 199  static void rdp_send_synchronise() Line 217  static void rdp_send_synchronise()
217  }  }
218    
219  /* Send a single input event */  /* Send a single input event */
220  void rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags,  void
221                      uint16 param1, uint16 param2)  rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
222  {  {
223          STREAM s;          STREAM s;
224    
225          s = rdp_init_data(16);          s = rdp_init_data(16);
226    
227          out_uint16_le(s, 1); /* number of events */          out_uint16_le(s, 1);    /* number of events */
228          out_uint16(s, 0);    /* pad */          out_uint16(s, 0);       /* pad */
229    
230          out_uint32_le(s, time);          out_uint32_le(s, time);
231          out_uint16_le(s, message_type);          out_uint16_le(s, message_type);
# Line 220  void rdp_send_input(uint32 time, uint16 Line 238  void rdp_send_input(uint32 time, uint16
238  }  }
239    
240  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
241  static void rdp_send_fonts(uint16 seq)  static void
242    rdp_send_fonts(uint16 seq)
243  {  {
244          STREAM s;          STREAM s;
245    
# Line 236  static void rdp_send_fonts(uint16 seq) Line 255  static void rdp_send_fonts(uint16 seq)
255  }  }
256    
257  /* Output general capability set */  /* Output general capability set */
258  static void rdp_out_general_caps(STREAM s)  static void
259    rdp_out_general_caps(STREAM s)
260  {  {
261          out_uint16_le(s, RDP_CAPSET_GENERAL);          out_uint16_le(s, RDP_CAPSET_GENERAL);
262          out_uint16_le(s, RDP_CAPLEN_GENERAL);          out_uint16_le(s, RDP_CAPLEN_GENERAL);
263    
264          out_uint16_le(s, 1);    /* OS major type */          out_uint16_le(s, 1);    /* OS major type */
265          out_uint16_le(s, 3);    /* OS minor type */          out_uint16_le(s, 3);    /* OS minor type */
266          out_uint16_le(s, 0x200); /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
267          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
268          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
269          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
# Line 254  static void rdp_out_general_caps(STREAM Line 274  static void rdp_out_general_caps(STREAM
274  }  }
275    
276  /* Output bitmap capability set */  /* Output bitmap capability set */
277  static void rdp_out_bitmap_caps(STREAM s)  static void
278    rdp_out_bitmap_caps(STREAM s)
279  {  {
280          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
281          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
282    
283          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, 8);    /* Preferred BPP */
284          out_uint16(s, 1);       /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
285          out_uint16(s, 1);       /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
286          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
287          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
288          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
289          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
290          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 0);       /* Allow resize */
291          out_uint16_le(s, 1);    /* Support compression */          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */
292          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
293          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
294          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
295  }  }
296    
297  /* Output order capability set */  /* Output order capability set */
298  static void rdp_out_order_caps(STREAM s)  static void
299    rdp_out_order_caps(STREAM s)
300  {  {
301          uint8 order_caps[32];          uint8 order_caps[32];
302    
         memset(order_caps, orders, 32);  
303    
304            memset(order_caps, 0, 32);
305            order_caps[0] = 1;      /* dest blt */
306            order_caps[1] = 1;      /* pat blt */
307            order_caps[2] = 1;      /* screen blt */
308            order_caps[3] = 1;      /* required for memblt? */
309            order_caps[8] = 1;      /* line */
310            order_caps[9] = 1;      /* line */
311            order_caps[10] = 1;     /* rect */
312            order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */
313            order_caps[13] = 1;     /* memblt */
314            order_caps[14] = 1;     /* triblt */
315            order_caps[22] = 1;     /* polyline */
316            order_caps[27] = 1;     /* text2 */
317          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
318          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
319    
# Line 289  static void rdp_out_order_caps(STREAM s) Line 323  static void rdp_out_order_caps(STREAM s)
323          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
324          out_uint16_le(s, 1);    /* Max order level */          out_uint16_le(s, 1);    /* Max order level */
325          out_uint16_le(s, 0x147);        /* Number of fonts */          out_uint16_le(s, 0x147);        /* Number of fonts */
326          out_uint16_le(s, 0x2a);         /* Capability flags */          out_uint16_le(s, 0x2a); /* Capability flags */
327          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
328          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
329          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
330          out_uint32(s, 0x38400); /* Desktop cache size */          out_uint32_le(s, desktop_save == False ? 0 : 0x38400);  /* Desktop cache size */
331          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
332          out_uint32(s, 0x4e4);   /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
333  }  }
334    
335  /* Output bitmap cache capability set */  /* Output bitmap cache capability set */
336  static void rdp_out_bmpcache_caps(STREAM s)  static void
337    rdp_out_bmpcache_caps(STREAM s)
338  {  {
339          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
340          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
341    
342          out_uint8s(s, 24); /* unused */          out_uint8s(s, 24);      /* unused */
343          out_uint16_le(s, 0x258); /* entries */          out_uint16_le(s, 0x258);        /* entries */
344          out_uint16_le(s, 0x100); /* max cell size */          out_uint16_le(s, 0x100);        /* max cell size */
345          out_uint16_le(s, 0x12c); /* entries */          out_uint16_le(s, 0x12c);        /* entries */
346          out_uint16_le(s, 0x400); /* max cell size */          out_uint16_le(s, 0x400);        /* max cell size */
347          out_uint16_le(s, 0x106); /* entries */          out_uint16_le(s, 0x106);        /* entries */
348          out_uint16_le(s, 0x1000); /* max cell size */          out_uint16_le(s, 0x1000);       /* max cell size */
349  }  }
350    
351  /* Output control capability set */  /* Output control capability set */
352  static void rdp_out_control_caps(STREAM s)  static void
353    rdp_out_control_caps(STREAM s)
354  {  {
355          out_uint16_le(s, RDP_CAPSET_CONTROL);          out_uint16_le(s, RDP_CAPSET_CONTROL);
356          out_uint16_le(s, RDP_CAPLEN_CONTROL);          out_uint16_le(s, RDP_CAPLEN_CONTROL);
# Line 326  static void rdp_out_control_caps(STREAM Line 362  static void rdp_out_control_caps(STREAM
362  }  }
363    
364  /* Output activation capability set */  /* Output activation capability set */
365  static void rdp_out_activate_caps(STREAM s)  static void
366    rdp_out_activate_caps(STREAM s)
367  {  {
368          out_uint16_le(s, RDP_CAPSET_ACTIVATE);          out_uint16_le(s, RDP_CAPSET_ACTIVATE);
369          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
# Line 338  static void rdp_out_activate_caps(STREAM Line 375  static void rdp_out_activate_caps(STREAM
375  }  }
376    
377  /* Output pointer capability set */  /* Output pointer capability set */
378  static void rdp_out_pointer_caps(STREAM s)  static void
379    rdp_out_pointer_caps(STREAM s)
380  {  {
381          out_uint16_le(s, RDP_CAPSET_POINTER);          out_uint16_le(s, RDP_CAPSET_POINTER);
382          out_uint16_le(s, RDP_CAPLEN_POINTER);          out_uint16_le(s, RDP_CAPLEN_POINTER);
# Line 348  static void rdp_out_pointer_caps(STREAM Line 386  static void rdp_out_pointer_caps(STREAM
386  }  }
387    
388  /* Output share capability set */  /* Output share capability set */
389  static void rdp_out_share_caps(STREAM s)  static void
390    rdp_out_share_caps(STREAM s)
391  {  {
392          out_uint16_le(s, RDP_CAPSET_SHARE);          out_uint16_le(s, RDP_CAPSET_SHARE);
393          out_uint16_le(s, RDP_CAPLEN_SHARE);          out_uint16_le(s, RDP_CAPLEN_SHARE);
# Line 358  static void rdp_out_share_caps(STREAM s) Line 397  static void rdp_out_share_caps(STREAM s)
397  }  }
398    
399  /* Output colour cache capability set */  /* Output colour cache capability set */
400  static void rdp_out_colcache_caps(STREAM s)  static void
401    rdp_out_colcache_caps(STREAM s)
402  {  {
403          out_uint16_le(s, RDP_CAPSET_COLCACHE);          out_uint16_le(s, RDP_CAPSET_COLCACHE);
404          out_uint16_le(s, RDP_CAPLEN_COLCACHE);          out_uint16_le(s, RDP_CAPLEN_COLCACHE);
# Line 368  static void rdp_out_colcache_caps(STREAM Line 408  static void rdp_out_colcache_caps(STREAM
408  }  }
409    
410  static uint8 canned_caps[] = {  static uint8 canned_caps[] = {
411  0x01,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
412  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
413  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
414  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
415  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
416  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x08,0x00,0x01,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
417  0x00,0x00,0x00,0x0E,0x00,0x08,0x00,0x01,0x00,0x00,0x00,0x10,0x00,0x34,0x00,0xFE,          0x00, 0x00, 0x00, 0x00, 0x00,
418  0x00,0x04,0x00,0xFE,0x00,0x04,0x00,0xFE,0x00,0x08,0x00,0xFE,0x00,0x08,0x00,0xFE,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419  0x00,0x10,0x00,0xFE,0x00,0x20,0x00,0xFE,0x00,0x40,0x00,0xFE,0x00,0x80,0x00,0xFE,          0x00, 0x00, 0x00, 0x00, 0x00,
420  0x00,0x00,0x01,0x40,0x00,0x00,0x08,0x00,0x01,0x00,0x01,0x02,0x00,0x00,0x00          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
421            0x0C, 0x00, 0x08, 0x00, 0x01,
422            0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
423            0x10, 0x00, 0x34, 0x00, 0xFE,
424            0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
425            0xFE, 0x00, 0x08, 0x00, 0xFE,
426            0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
427            0xFE, 0x00, 0x80, 0x00, 0xFE,
428            0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
429            0x02, 0x00, 0x00, 0x00
430  };  };
431    
432  /* Output unknown capability set */  /* Output unknown capability set */
433  static void rdp_out_unknown_caps(STREAM s)  static void
434    rdp_out_unknown_caps(STREAM s)
435  {  {
436          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, RDP_CAPSET_UNKNOWN);
437          out_uint16_le(s, 0x58);          out_uint16_le(s, 0x58);
438            
439          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN-4);          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);
440  }  }
441    
442  /* Send a confirm active PDU */  /* Send a confirm active PDU */
443  static void rdp_send_confirm_active()  static void
444    rdp_send_confirm_active(void)
445  {  {
446          STREAM s;          STREAM s;
447          uint16 caplen = RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER          uint16 caplen =
448                  + RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE + RDP_CAPLEN_ACTIVATE                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
449                  + RDP_CAPLEN_CONTROL + RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
450                  + RDP_CAPLEN_UNKNOWN;                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
451                    RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
452    
453          s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));          s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));
454    
455          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, rdp_shareid);
456          out_uint16_le(s, 0x3ea); /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
457          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
458          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
459    
460          out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));          out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));
461          out_uint16_le(s, 0xd); /* num_caps */          out_uint16_le(s, 0xd);  /* num_caps */
462          out_uint8s(s, 2);     /* pad */          out_uint8s(s, 2);       /* pad */
463    
464          rdp_out_general_caps(s);          rdp_out_general_caps(s);
465          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
# Line 425  static void rdp_send_confirm_active() Line 477  static void rdp_send_confirm_active()
477  }  }
478    
479  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
480  static void process_demand_active(STREAM s)  static void
481    process_demand_active(STREAM s)
482  {  {
483          uint8 type;          uint8 type;
484    
485          in_uint32_le(s, rdp_shareid);          in_uint32_le(s, rdp_shareid);
486    
487          DEBUG("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid);          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));
488    
489          rdp_send_confirm_active();          rdp_send_confirm_active();
490          rdp_send_synchronise();          rdp_send_synchronise();
491          rdp_send_control(RDP_CTL_COOPERATE);          rdp_send_control(RDP_CTL_COOPERATE);
492          rdp_send_control(RDP_CTL_REQUEST_CONTROL);          rdp_send_control(RDP_CTL_REQUEST_CONTROL);
493          rdp_recv(&type); // RDP_PDU_SYNCHRONIZE          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
494          rdp_recv(&type); // RDP_CTL_COOPERATE          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
495          rdp_recv(&type); // RDP_CTL_GRANT_CONTROL          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
496          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);
497          rdp_send_fonts(1);          rdp_send_fonts(1);
498          rdp_send_fonts(2);          rdp_send_fonts(2);
499          rdp_recv(&type); // RDP_PDU_UNKNOWN 0x28          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
500          reset_order_state();          reset_order_state();
501  }  }
502    
503  /* Process a pointer PDU */  /* Process a pointer PDU */
504  static void process_pointer_pdu(STREAM s)  static void
505    process_pointer_pdu(STREAM s)
506  {  {
507          uint16 message_type;          uint16 message_type;
508          uint16 x, y;          uint16 x, y, width, height, cache_idx, masklen, datalen;
509            uint8 *mask, *data;
510            HCURSOR cursor;
511    
512          in_uint16_le(s, message_type);          in_uint16_le(s, message_type);
513          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
514    
515          switch (message_type)          switch (message_type)
516          {          {
# Line 465  static void process_pointer_pdu(STREAM s Line 521  static void process_pointer_pdu(STREAM s
521                                  ui_move_pointer(x, y);                                  ui_move_pointer(x, y);
522                          break;                          break;
523    
524                    case RDP_POINTER_COLOR:
525                            in_uint16_le(s, cache_idx);
526                            in_uint16_le(s, x);
527                            in_uint16_le(s, y);
528                            in_uint16_le(s, width);
529                            in_uint16_le(s, height);
530                            in_uint16_le(s, masklen);
531                            in_uint16_le(s, datalen);
532                            in_uint8p(s, data, datalen);
533                            in_uint8p(s, mask, masklen);
534                            cursor = ui_create_cursor(x, y, width, height, mask, data);
535                            ui_set_cursor(cursor);
536                            cache_put_cursor(cache_idx, cursor);
537                            break;
538    
539                    case RDP_POINTER_CACHED:
540                            in_uint16_le(s, cache_idx);
541                            ui_set_cursor(cache_get_cursor(cache_idx));
542                            break;
543    
544                  default:                  default:
545                          DEBUG("Pointer message 0x%x\n", message_type);                          DEBUG(("Pointer message 0x%x\n", message_type));
546          }          }
547  }  }
548    
549  /* Process bitmap updates */  /* Process bitmap updates */
550  static void process_bitmap_updates(STREAM s)  static void
551    process_bitmap_updates(STREAM s)
552  {  {
553          uint16 num_updates;          uint16 num_updates;
554          uint16 left, top, right, bottom, width, height;          uint16 left, top, right, bottom, width, height;
555          uint16 cx, cy, bpp, compress, bufsize, size;          uint16 cx, cy, bpp, compress, bufsize, size;
556          uint8 *data, *rawdata;          uint8 *data, *bmpdata;
557          int i;          int i;
558    
559          in_uint16_le(s, num_updates);          in_uint16_le(s, num_updates);
# Line 496  static void process_bitmap_updates(STREA Line 573  static void process_bitmap_updates(STREA
573                  cx = right - left + 1;                  cx = right - left + 1;
574                  cy = bottom - top + 1;                  cy = bottom - top + 1;
575    
576                  DEBUG("UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,cmp=%d)\n",                  DEBUG(("UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,cmp=%d)\n",
577                          left, top, right, bottom, width, height, compress);                         left, top, right, bottom, width, height, compress));
578    
579                  if (!compress)                  if (!compress)
580                  {                  {
581                          in_uint8p(s, data, bufsize);                          int y;
582                          ui_paint_bitmap(left, top, cx, cy, width, height, data);                          bmpdata = xmalloc(width * height);
583                          return;                          for (y = 0; y < height; y++)
584                            {
585                                    in_uint8a(s, &bmpdata[(height - y - 1) * width], width);
586                            }
587                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
588                            xfree(bmpdata);
589                            continue;
590                  }                  }
591    
592                  in_uint8s(s, 2); /* pad */                  in_uint8s(s, 2);        /* pad */
593                  in_uint16_le(s, size);                  in_uint16_le(s, size);
594                  in_uint8s(s, 4); /* line_size, final_size */                  in_uint8s(s, 4);        /* line_size, final_size */
595                  in_uint8p(s, data, size);                  in_uint8p(s, data, size);
596    
597                  rawdata = xmalloc(width * height);                  bmpdata = xmalloc(width * height);
598                  if (bitmap_decompress(rawdata, width, height, data, size))                  if (bitmap_decompress(bmpdata, width, height, data, size))
599                  {                  {
600                          ui_paint_bitmap(left, top, cx, cy, width, height,                          ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
                                         rawdata);  
601                  }                  }
602    
603                  xfree(rawdata);                  xfree(bmpdata);
604          }          }
605  }  }
606    
607  /* Process a palette update */  /* Process a palette update */
608  static void process_palette(STREAM s)  static void
609    process_palette(STREAM s)
610  {  {
611          HCOLOURMAP hmap;          COLOURENTRY *entry;
612          COLOURMAP map;          COLOURMAP map;
613            HCOLOURMAP hmap;
614            int i;
615    
616            in_uint8s(s, 2);        /* pad */
617            in_uint16_le(s, map.ncolours);
618            in_uint8s(s, 2);        /* pad */
619    
620          in_uint8s(s, 2); /* pad */          map.colours = xmalloc(3 * map.ncolours);
621          in_uint16_le(s, map.ncolours);  
622          in_uint8s(s, 2); /* pad */          for (i = 0; i < map.ncolours; i++)
623          in_uint8p(s, (uint8 *)map.colours, (map.ncolours * 3));          {
624                    entry = &map.colours[i];
625                    in_uint8(s, entry->red);
626                    in_uint8(s, entry->green);
627                    in_uint8(s, entry->blue);
628            }
629    
630          hmap = ui_create_colourmap(&map);          hmap = ui_create_colourmap(&map);
631          ui_set_colourmap(hmap);          ui_set_colourmap(hmap);
632    
633            xfree(map.colours);
634  }  }
635    
636  /* Process an update PDU */  /* Process an update PDU */
637  static void process_update_pdu(STREAM s)  static void
638    process_update_pdu(STREAM s)
639  {  {
640          uint16 update_type;          uint16 update_type;
641    
# Line 562  static void process_update_pdu(STREAM s) Line 659  static void process_update_pdu(STREAM s)
659                          break;                          break;
660    
661                  default:                  default:
662                          NOTIMP("update %d\n", update_type);                          unimpl("update %d\n", update_type);
663          }          }
664    
665  }  }
666    
667  /* Process data PDU */  /* Process data PDU */
668  static void process_data_pdu(STREAM s)  static void
669    process_data_pdu(STREAM s)
670  {  {
671          uint8 data_pdu_type;          uint8 data_pdu_type;
672    
673          in_uint8s(s, 8); /* shareid, pad, streamid, length */          in_uint8s(s, 8);        /* shareid, pad, streamid, length */
674          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
675          in_uint8s(s, 3); /* compress_type, compress_len */          in_uint8s(s, 3);        /* compress_type, compress_len */
676    
677          switch (data_pdu_type)          switch (data_pdu_type)
678          {          {
# Line 595  static void process_data_pdu(STREAM s) Line 693  static void process_data_pdu(STREAM s)
693                          break;                          break;
694    
695                  default:                  default:
696                          NOTIMP("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
697          }          }
698  }  }
699    
700  /* Process incoming packets */  /* Process incoming packets */
701  void rdp_main_loop()  void
702    rdp_main_loop(void)
703  {  {
704          uint8 type;          uint8 type;
705          STREAM s;          STREAM s;
# Line 620  void rdp_main_loop() Line 719  void rdp_main_loop()
719                                  process_data_pdu(s);                                  process_data_pdu(s);
720                                  break;                                  break;
721    
722                            case 0:
723                                    break;
724    
725                          default:                          default:
726                                  NOTIMP("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
727                  }                  }
728          }          }
729  }  }
730    
731  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
732  BOOL rdp_connect(char *server)  BOOL
733    rdp_connect(char *server, uint32 flags, char *domain, char *password,
734                char *command, char *directory)
735  {  {
736          if (!sec_connect(server))          if (!sec_connect(server))
737                  return False;                  return False;
738    
739          rdp_send_logon_info(0x33, "", username, "", "", "");          rdp_send_logon_info(flags, domain, username, password, command, directory);
740          return True;          return True;
741  }  }
742    
743  /* Disconnect from the RDP layer */  /* Disconnect from the RDP layer */
744  void rdp_disconnect()  void
745    rdp_disconnect(void)
746  {  {
747          sec_disconnect();          sec_disconnect();
748  }  }
   
Legend:
Removed from v.10  
changed lines
  Added in v.283
  ViewVC Help
Powered by ViewVC 1.1.26