/[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 24 by matty, Sat Jan 6 03:12:10 2001 UTC revision 82 by astrand, Tue Jul 30 07:18:48 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-2001
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 50  static void rdp_send(STREAM s, uint8 pdu Line 55  static void rdp_send(STREAM s, uint8 pdu
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 75  static STREAM rdp_recv(uint8 *type) Line 81  static STREAM rdp_recv(uint8 *type)
81          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
82          in_uint16_le(rdp_s, pdu_type);          in_uint16_le(rdp_s, pdu_type);
83          in_uint8s(rdp_s, 2);    /* userid */          in_uint8s(rdp_s, 2);    /* userid */
   
         next_packet += length;  
84          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
85    
86  #if RDP_DEBUG  #if WITH_DEBUG
87          DEBUG("RDP packet (type %x):\n", *type);          DEBUG(("RDP packet (type %x):\n", *type));
88          hexdump(rdp_s->p, length);          hexdump(next_packet, length);
89  #endif  #endif /*  */
90    
91            next_packet += length;
92          return rdp_s;          return rdp_s;
93  }  }
94    
95  /* Initialise an RDP data packet */  /* Initialise an RDP data packet */
96  static STREAM rdp_init_data(int maxlen)  static STREAM
97    rdp_init_data(int maxlen)
98  {  {
99          STREAM s;          STREAM s;
100    
101          s = sec_init(SEC_ENCRYPT, maxlen + 18);          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);
102          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
103    
104          return s;          return s;
105  }  }
106    
107  /* Send an RDP data packet */  /* Send an RDP data packet */
108  static void rdp_send_data(STREAM s, uint8 data_pdu_type)  static void
109    rdp_send_data(STREAM s, uint8 data_pdu_type)
110  {  {
111          uint16 length;          uint16 length;
112    
# Line 118  static void rdp_send_data(STREAM s, uint Line 125  static void rdp_send_data(STREAM s, uint
125          out_uint8(s, 0);        /* compress_type */          out_uint8(s, 0);        /* compress_type */
126          out_uint16(s, 0);       /* compress_len */          out_uint16(s, 0);       /* compress_len */
127    
128          sec_send(s, SEC_ENCRYPT);          sec_send(s, encryption ? SEC_ENCRYPT : 0);
129  }  }
130    
131  /* Output a string in Unicode */  /* Output a string in Unicode */
132  void rdp_out_unistr(STREAM s, char *string, int len)  void
133    rdp_out_unistr(STREAM s, char *string, int len)
134  {  {
135          int i = 0, j = 0;          int i = 0, j = 0;
136    
# Line 138  void rdp_out_unistr(STREAM s, char *stri Line 146  void rdp_out_unistr(STREAM s, char *stri
146  }  }
147    
148  /* Parse a logon info packet */  /* Parse a logon info packet */
149  static void rdp_send_logon_info(uint32 flags, char *domain, char *user,  static void
150                                  char *password, char *program,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
151                                  char *directory)                      char *password, char *program, char *directory)
152  {  {
153          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
154          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
155          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
156          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
157          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
158          uint32 sec_flags = SEC_LOGON_INFO | SEC_ENCRYPT;          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
159          STREAM s;          STREAM s;
160    
161          s = sec_init(sec_flags, 18 + len_domain + len_user + len_password          s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
# Line 171  static void rdp_send_logon_info(uint32 f Line 179  static void rdp_send_logon_info(uint32 f
179  }  }
180    
181  /* Send a control PDU */  /* Send a control PDU */
182  static void rdp_send_control(uint16 action)  static void
183    rdp_send_control(uint16 action)
184  {  {
185          STREAM s;          STREAM s;
186    
# Line 186  static void rdp_send_control(uint16 acti Line 195  static void rdp_send_control(uint16 acti
195  }  }
196    
197  /* Send a synchronisation PDU */  /* Send a synchronisation PDU */
198  static void rdp_send_synchronise()  static void
199    rdp_send_synchronise()
200  {  {
201          STREAM s;          STREAM s;
202    
# Line 200  static void rdp_send_synchronise() Line 210  static void rdp_send_synchronise()
210  }  }
211    
212  /* Send a single input event */  /* Send a single input event */
213  void rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags,  void
214                      uint16 param1, uint16 param2)  rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
215  {  {
216          STREAM s;          STREAM s;
217    
# Line 221  void rdp_send_input(uint32 time, uint16 Line 231  void rdp_send_input(uint32 time, uint16
231  }  }
232    
233  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
234  static void rdp_send_fonts(uint16 seq)  static void
235    rdp_send_fonts(uint16 seq)
236  {  {
237          STREAM s;          STREAM s;
238    
# Line 237  static void rdp_send_fonts(uint16 seq) Line 248  static void rdp_send_fonts(uint16 seq)
248  }  }
249    
250  /* Output general capability set */  /* Output general capability set */
251  static void rdp_out_general_caps(STREAM s)  static void
252    rdp_out_general_caps(STREAM s)
253  {  {
254          out_uint16_le(s, RDP_CAPSET_GENERAL);          out_uint16_le(s, RDP_CAPSET_GENERAL);
255          out_uint16_le(s, RDP_CAPLEN_GENERAL);          out_uint16_le(s, RDP_CAPLEN_GENERAL);
# Line 255  static void rdp_out_general_caps(STREAM Line 267  static void rdp_out_general_caps(STREAM
267  }  }
268    
269  /* Output bitmap capability set */  /* Output bitmap capability set */
270  static void rdp_out_bitmap_caps(STREAM s)  static void
271    rdp_out_bitmap_caps(STREAM s)
272  {  {
273          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
274          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
# Line 268  static void rdp_out_bitmap_caps(STREAM s Line 281  static void rdp_out_bitmap_caps(STREAM s
281          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
282          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
283          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 0);       /* Allow resize */
284          out_uint16_le(s, 1);    /* Support compression */          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */
285          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
286          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
287          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
288  }  }
289    
290  /* Output order capability set */  /* Output order capability set */
291  static void rdp_out_order_caps(STREAM s)  static void
292    rdp_out_order_caps(STREAM s)
293  {  {
294          uint8 order_caps[32];          uint8 order_caps[32];
295    
         memset(order_caps, orders, 32);  
296    
297            memset(order_caps, 0, 32);
298            order_caps[0] = 1;      /* dest blt */
299            order_caps[1] = 1;      /* pat blt */
300            order_caps[2] = 1;      /* screen blt */
301            order_caps[8] = 1;      /* line */
302            order_caps[9] = 1;      /* line */
303            order_caps[10] = 1;     /* rect */
304            order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */
305            order_caps[13] = 1;     /* memblt */
306            order_caps[14] = 1;     /* triblt */
307            order_caps[22] = 1;     /* polyline */
308            order_caps[27] = 1;     /* text2 */
309          out_uint16_le(s, RDP_CAPSET_ORDER);          out_uint16_le(s, RDP_CAPSET_ORDER);
310          out_uint16_le(s, RDP_CAPLEN_ORDER);          out_uint16_le(s, RDP_CAPLEN_ORDER);
311    
# Line 294  static void rdp_out_order_caps(STREAM s) Line 319  static void rdp_out_order_caps(STREAM s)
319          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
320          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
321          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
322          out_uint32(s, 0x38400); /* Desktop cache size */          out_uint32(s, desktop_save == False ? 0 : 0x38400);     /* Desktop cache size */
323          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
324          out_uint32(s, 0x4e4);   /* Unknown */          out_uint32(s, 0x4e4);   /* Unknown */
325  }  }
326    
327  /* Output bitmap cache capability set */  /* Output bitmap cache capability set */
328  static void rdp_out_bmpcache_caps(STREAM s)  static void
329    rdp_out_bmpcache_caps(STREAM s)
330  {  {
331          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
332          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
# Line 315  static void rdp_out_bmpcache_caps(STREAM Line 341  static void rdp_out_bmpcache_caps(STREAM
341  }  }
342    
343  /* Output control capability set */  /* Output control capability set */
344  static void rdp_out_control_caps(STREAM s)  static void
345    rdp_out_control_caps(STREAM s)
346  {  {
347          out_uint16_le(s, RDP_CAPSET_CONTROL);          out_uint16_le(s, RDP_CAPSET_CONTROL);
348          out_uint16_le(s, RDP_CAPLEN_CONTROL);          out_uint16_le(s, RDP_CAPLEN_CONTROL);
# Line 327  static void rdp_out_control_caps(STREAM Line 354  static void rdp_out_control_caps(STREAM
354  }  }
355    
356  /* Output activation capability set */  /* Output activation capability set */
357  static void rdp_out_activate_caps(STREAM s)  static void
358    rdp_out_activate_caps(STREAM s)
359  {  {
360          out_uint16_le(s, RDP_CAPSET_ACTIVATE);          out_uint16_le(s, RDP_CAPSET_ACTIVATE);
361          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
# Line 339  static void rdp_out_activate_caps(STREAM Line 367  static void rdp_out_activate_caps(STREAM
367  }  }
368    
369  /* Output pointer capability set */  /* Output pointer capability set */
370  static void rdp_out_pointer_caps(STREAM s)  static void
371    rdp_out_pointer_caps(STREAM s)
372  {  {
373          out_uint16_le(s, RDP_CAPSET_POINTER);          out_uint16_le(s, RDP_CAPSET_POINTER);
374          out_uint16_le(s, RDP_CAPLEN_POINTER);          out_uint16_le(s, RDP_CAPLEN_POINTER);
# Line 349  static void rdp_out_pointer_caps(STREAM Line 378  static void rdp_out_pointer_caps(STREAM
378  }  }
379    
380  /* Output share capability set */  /* Output share capability set */
381  static void rdp_out_share_caps(STREAM s)  static void
382    rdp_out_share_caps(STREAM s)
383  {  {
384          out_uint16_le(s, RDP_CAPSET_SHARE);          out_uint16_le(s, RDP_CAPSET_SHARE);
385          out_uint16_le(s, RDP_CAPLEN_SHARE);          out_uint16_le(s, RDP_CAPLEN_SHARE);
# Line 359  static void rdp_out_share_caps(STREAM s) Line 389  static void rdp_out_share_caps(STREAM s)
389  }  }
390    
391  /* Output colour cache capability set */  /* Output colour cache capability set */
392  static void rdp_out_colcache_caps(STREAM s)  static void
393    rdp_out_colcache_caps(STREAM s)
394  {  {
395          out_uint16_le(s, RDP_CAPSET_COLCACHE);          out_uint16_le(s, RDP_CAPSET_COLCACHE);
396          out_uint16_le(s, RDP_CAPLEN_COLCACHE);          out_uint16_le(s, RDP_CAPLEN_COLCACHE);
# Line 371  static void rdp_out_colcache_caps(STREAM Line 402  static void rdp_out_colcache_caps(STREAM
402  static uint8 canned_caps[] = {  static uint8 canned_caps[] = {
403          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
404          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
405                  0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
406          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
407                  0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
408          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
409                  0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
410          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
411                  0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00,
412          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
413                  0x0C, 0x00, 0x08, 0x00, 0x01,          0x0C, 0x00, 0x08, 0x00, 0x01,
414          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
415                  0x10, 0x00, 0x34, 0x00, 0xFE,          0x10, 0x00, 0x34, 0x00, 0xFE,
416          0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,          0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
417                  0xFE, 0x00, 0x08, 0x00, 0xFE,          0xFE, 0x00, 0x08, 0x00, 0xFE,
418          0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,          0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
419                  0xFE, 0x00, 0x80, 0x00, 0xFE,          0xFE, 0x00, 0x80, 0x00, 0xFE,
420          0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,          0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
421                  0x02, 0x00, 0x00, 0x00          0x02, 0x00, 0x00, 0x00
422  };  };
423    
424  /* Output unknown capability set */  /* Output unknown capability set */
425  static void rdp_out_unknown_caps(STREAM s)  static void
426    rdp_out_unknown_caps(STREAM s)
427  {  {
428          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, RDP_CAPSET_UNKNOWN);
429          out_uint16_le(s, 0x58);          out_uint16_le(s, 0x58);
# Line 400  static void rdp_out_unknown_caps(STREAM Line 432  static void rdp_out_unknown_caps(STREAM
432  }  }
433    
434  /* Send a confirm active PDU */  /* Send a confirm active PDU */
435  static void rdp_send_confirm_active()  static void
436    rdp_send_confirm_active()
437  {  {
438          STREAM s;          STREAM s;
439          uint16 caplen =          uint16 caplen =
440                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
441                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
442                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
443                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
444    
445          s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));          s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));
446    
# Line 436  static void rdp_send_confirm_active() Line 469  static void rdp_send_confirm_active()
469  }  }
470    
471  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
472  static void process_demand_active(STREAM s)  static void
473    process_demand_active(STREAM s)
474  {  {
475          uint8 type;          uint8 type;
476    
477          in_uint32_le(s, rdp_shareid);          in_uint32_le(s, rdp_shareid);
478    
479          DEBUG("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid);          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));
480    
481          rdp_send_confirm_active();          rdp_send_confirm_active();
482          rdp_send_synchronise();          rdp_send_synchronise();
483          rdp_send_control(RDP_CTL_COOPERATE);          rdp_send_control(RDP_CTL_COOPERATE);
484          rdp_send_control(RDP_CTL_REQUEST_CONTROL);          rdp_send_control(RDP_CTL_REQUEST_CONTROL);
485          rdp_recv(&type);        // RDP_PDU_SYNCHRONIZE          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
486          rdp_recv(&type);        // RDP_CTL_COOPERATE          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
487          rdp_recv(&type);        // RDP_CTL_GRANT_CONTROL          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
488          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);
489          rdp_send_fonts(1);          rdp_send_fonts(1);
490          rdp_send_fonts(2);          rdp_send_fonts(2);
491          rdp_recv(&type);        // RDP_PDU_UNKNOWN 0x28          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
492          reset_order_state();          reset_order_state();
493  }  }
494    
495  /* Process a pointer PDU */  /* Process a pointer PDU */
496  static void process_pointer_pdu(STREAM s)  static void
497    process_pointer_pdu(STREAM s)
498  {  {
499          uint16 message_type;          uint16 message_type;
500          uint16 x, y;          uint16 x, y, width, height, cache_idx, masklen, datalen;
501            uint8 *mask, *data;
502            HCURSOR cursor;
503    
504          in_uint16_le(s, message_type);          in_uint16_le(s, message_type);
505          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
# Line 476  static void process_pointer_pdu(STREAM s Line 513  static void process_pointer_pdu(STREAM s
513                                  ui_move_pointer(x, y);                                  ui_move_pointer(x, y);
514                          break;                          break;
515    
516                    case RDP_POINTER_COLOR:
517                            in_uint16_le(s, cache_idx);
518                            in_uint16_le(s, x);
519                            in_uint16_le(s, y);
520                            in_uint16_le(s, width);
521                            in_uint16_le(s, height);
522                            in_uint16_le(s, masklen);
523                            in_uint16_le(s, datalen);
524                            in_uint8p(s, data, datalen);
525                            in_uint8p(s, mask, masklen);
526                            cursor = ui_create_cursor(x, y, width, height, mask, data);
527                            ui_set_cursor(cursor);
528                            cache_put_cursor(cache_idx, cursor);
529                            break;
530    
531                    case RDP_POINTER_CACHED:
532                            in_uint16_le(s, cache_idx);
533                            ui_set_cursor(cache_get_cursor(cache_idx));
534                            break;
535    
536                  default:                  default:
537                          DEBUG("Pointer message 0x%x\n", message_type);                          DEBUG(("Pointer message 0x%x\n", message_type));
538          }          }
539  }  }
540    
541  /* Process bitmap updates */  /* Process bitmap updates */
542  static void process_bitmap_updates(STREAM s)  static void
543    process_bitmap_updates(STREAM s)
544  {  {
545          uint16 num_updates;          uint16 num_updates;
546          uint16 left, top, right, bottom, width, height;          uint16 left, top, right, bottom, width, height;
547          uint16 cx, cy, bpp, compress, bufsize, size;          uint16 cx, cy, bpp, compress, bufsize, size;
548          uint8 *data, *rawdata;          uint8 *data, *bmpdata;
549          int i;          int i;
550    
551          in_uint16_le(s, num_updates);          in_uint16_le(s, num_updates);
# Line 507  static void process_bitmap_updates(STREA Line 565  static void process_bitmap_updates(STREA
565                  cx = right - left + 1;                  cx = right - left + 1;
566                  cy = bottom - top + 1;                  cy = bottom - top + 1;
567    
568                  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",
569                        left, top, right, bottom, width, height, compress);                         left, top, right, bottom, width, height, compress));
570    
571                  if (!compress)                  if (!compress)
572                  {                  {
573                          in_uint8p(s, data, bufsize);                          int y;
574                          ui_paint_bitmap(left, top, cx, cy, width, height,                          bmpdata = xmalloc(width * height);
575                                          data);                          for (y = 0; y < height; y++)
576                          return;                          {
577                                    in_uint8a(s, &bmpdata[(height - y - 1) * width], width);
578                            }
579                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
580                            xfree(bmpdata);
581                            continue;
582                  }                  }
583    
584                  in_uint8s(s, 2);        /* pad */                  in_uint8s(s, 2);        /* pad */
# Line 523  static void process_bitmap_updates(STREA Line 586  static void process_bitmap_updates(STREA
586                  in_uint8s(s, 4);        /* line_size, final_size */                  in_uint8s(s, 4);        /* line_size, final_size */
587                  in_uint8p(s, data, size);                  in_uint8p(s, data, size);
588    
589                  rawdata = xmalloc(width * height);                  bmpdata = xmalloc(width * height);
590                  if (bitmap_decompress(rawdata, width, height, data, size))                  if (bitmap_decompress(bmpdata, width, height, data, size))
591                  {                  {
592                          ui_paint_bitmap(left, top, cx, cy, width, height,                          ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
                                         rawdata);  
593                  }                  }
594    
595                  xfree(rawdata);                  xfree(bmpdata);
596          }          }
597  }  }
598    
599  /* Process a palette update */  /* Process a palette update */
600  static void process_palette(STREAM s)  static void
601    process_palette(STREAM s)
602  {  {
603          HCOLOURMAP hmap;          HCOLOURMAP hmap;
604          COLOURMAP map;          COLOURMAP map;
605            uint8 *colours;
606    
607          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
608          in_uint16_le(s, map.ncolours);          in_uint16_le(s, map.ncolours);
609          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
610          in_uint8p(s, (uint8 *) map.colours, (map.ncolours * 3));          in_uint8p(s, colours, (map.ncolours * 3));
611            map.colours = (COLOURENTRY *) colours;
612    
613          hmap = ui_create_colourmap(&map);          hmap = ui_create_colourmap(&map);
614          ui_set_colourmap(hmap);          ui_set_colourmap(hmap);
615  }  }
616    
617  /* Process an update PDU */  /* Process an update PDU */
618  static void process_update_pdu(STREAM s)  static void
619    process_update_pdu(STREAM s)
620  {  {
621          uint16 update_type;          uint16 update_type;
622    
# Line 574  static void process_update_pdu(STREAM s) Line 640  static void process_update_pdu(STREAM s)
640                          break;                          break;
641    
642                  default:                  default:
643                          NOTIMP("update %d\n", update_type);                          unimpl("update %d\n", update_type);
644          }          }
645    
646  }  }
647    
648  /* Process data PDU */  /* Process data PDU */
649  static void process_data_pdu(STREAM s)  static void
650    process_data_pdu(STREAM s)
651  {  {
652          uint8 data_pdu_type;          uint8 data_pdu_type;
653    
# Line 607  static void process_data_pdu(STREAM s) Line 674  static void process_data_pdu(STREAM s)
674                          break;                          break;
675    
676                  default:                  default:
677                          NOTIMP("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
678          }          }
679  }  }
680    
681  /* Process incoming packets */  /* Process incoming packets */
682  void rdp_main_loop()  void
683    rdp_main_loop()
684  {  {
685          uint8 type;          uint8 type;
686          STREAM s;          STREAM s;
# Line 633  void rdp_main_loop() Line 701  void rdp_main_loop()
701                                  break;                                  break;
702    
703                          default:                          default:
704                                  NOTIMP("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
705                  }                  }
706          }          }
707  }  }
708    
709  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
710  BOOL rdp_connect(char *server, uint32 flags, char *domain, char *password,  BOOL
711                   char *command, char *directory)  rdp_connect(char *server, uint32 flags, char *domain, char *password,
712                char *command, char *directory)
713  {  {
714          if (!sec_connect(server))          if (!sec_connect(server))
715                  return False;                  return False;
716    
717          rdp_send_logon_info(flags, domain, username, password,          rdp_send_logon_info(flags, domain, username, password, command, directory);
                             command, directory);  
718          return True;          return True;
719  }  }
720    
721  /* Disconnect from the RDP layer */  /* Disconnect from the RDP layer */
722  void rdp_disconnect()  void
723    rdp_disconnect()
724  {  {
725          sec_disconnect();          sec_disconnect();
726  }  }
Legend:
Removed from v.24  
changed lines
  Added in v.82
  ViewVC Help
Powered by ViewVC 1.1.26