/[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 436 by jsorg71, Mon Jul 28 18:13:30 2003 UTC revision 677 by n-ki, Mon Apr 26 13:48:39 2004 UTC
# Line 18  Line 18 
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 g_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 int server_bpp;  extern uint32 g_rdp5_performanceflags;
33    extern int g_server_bpp;
34    extern int g_width;
35    extern int g_height;
36    
37  uint8 *next_packet;  uint8 *g_next_packet;
38  uint32 rdp_shareid;  uint32 g_rdp_shareid;
39    
40  #if WITH_DEBUG  #if WITH_DEBUG
41  static uint32 packetno;  static uint32 g_packetno;
42  #endif  #endif
43    
44  /* Receive an RDP packet */  /* Receive an RDP packet */
# Line 44  rdp_recv(uint8 * type) Line 48  rdp_recv(uint8 * type)
48          static STREAM rdp_s;          static STREAM rdp_s;
49          uint16 length, pdu_type;          uint16 length, pdu_type;
50    
51          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
52          {          {
53                  rdp_s = sec_recv();                  rdp_s = sec_recv();
54                  if (rdp_s == NULL)                  if (rdp_s == NULL)
55                          return NULL;                          return NULL;
56    
57                  next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
58          }          }
59          else          else
60          {          {
61                  rdp_s->p = next_packet;                  rdp_s->p = g_next_packet;
62          }          }
63    
64          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
65          /* 32k packets are really 8, keepalive fix */          /* 32k packets are really 8, keepalive fix */
66          if (length == 0x8000)          if (length == 0x8000)
67          {          {
68                  next_packet += 8;                  g_next_packet += 8;
69                  *type = 0;                  *type = 0;
70                  return rdp_s;                  return rdp_s;
71          }          }
# Line 70  rdp_recv(uint8 * type) Line 74  rdp_recv(uint8 * type)
74          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
75    
76  #if WITH_DEBUG  #if WITH_DEBUG
77          DEBUG(("RDP packet #%d, (type %x)\n", ++packetno, *type));          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
78          //      hexdump(next_packet, length);          hexdump(g_next_packet, length);
79  #endif /*  */  #endif /*  */
80    
81          next_packet += length;          g_next_packet += length;
82          return rdp_s;          return rdp_s;
83  }  }
84    
# Line 84  rdp_init_data(int maxlen) Line 88  rdp_init_data(int maxlen)
88  {  {
89          STREAM s;          STREAM s;
90    
91          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
92          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
93    
94          return s;          return s;
# Line 103  rdp_send_data(STREAM s, uint8 data_pdu_t Line 107  rdp_send_data(STREAM s, uint8 data_pdu_t
107          out_uint16_le(s, (RDP_PDU_DATA | 0x10));          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
108          out_uint16_le(s, (g_mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
109    
110          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
111          out_uint8(s, 0);        /* pad */          out_uint8(s, 0);        /* pad */
112          out_uint8(s, 1);        /* streamid */          out_uint8(s, 1);        /* streamid */
113          out_uint16_le(s, (length - 14));          out_uint16_le(s, (length - 14));
# Line 111  rdp_send_data(STREAM s, uint8 data_pdu_t Line 115  rdp_send_data(STREAM s, uint8 data_pdu_t
115          out_uint8(s, 0);        /* compress_type */          out_uint8(s, 0);        /* compress_type */
116          out_uint16(s, 0);       /* compress_len */          out_uint16(s, 0);       /* compress_len */
117    
118          sec_send(s, encryption ? SEC_ENCRYPT : 0);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
119  }  }
120    
121  /* Output a string in Unicode */  /* Output a string in Unicode */
# Line 131  rdp_out_unistr(STREAM s, char *string, i Line 135  rdp_out_unistr(STREAM s, char *string, i
135          s->p += len;          s->p += len;
136  }  }
137    
138    /* Input a string in Unicode
139     *
140     * Returns str_len of string
141     */
142    int
143    rdp_in_unistr(STREAM s, char *string, int uni_len)
144    {
145            int i = 0;
146    
147            while (i < uni_len / 2)
148            {
149                    in_uint8a(s, &string[i++], 1);
150                    in_uint8s(s, 1);
151            }
152    
153            return i - 1;
154    }
155    
156    
157  /* Parse a logon info packet */  /* Parse a logon info packet */
158  static void  static void
159  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
160                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
161  {  {
162            char *ipaddr = tcp_get_address();
163          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
164          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
165          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
166          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
167          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
168          int len_ip = 2 * strlen("127.0.0.1");          int len_ip = 2 * strlen(ipaddr);
169          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
170          int packetlen = 0;          int packetlen = 0;
171          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;          uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
172          STREAM s;          STREAM s;
173            time_t t = time(NULL);
174            time_t tzone;
175    
176    #if 0
177            // enable rdp compression
178            flags |= RDP_COMPRESSION;
179    #endif
180    
181          if (!use_rdp5 || 1 == server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
182          {          {
183                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
184    
# Line 171  rdp_send_logon_info(uint32 flags, char * Line 202  rdp_send_logon_info(uint32 flags, char *
202          {          {
203                  flags |= RDP_LOGON_BLOB;                  flags |= RDP_LOGON_BLOB;
204                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
205                  packetlen = 4 + // Unknown uint32                  packetlen = 4 + /* Unknown uint32 */
206                          4 +     // flags                          4 +     /* flags */
207                          2 +     // len_domain                          2 +     /* len_domain */
208                          2 +     // len_user                          2 +     /* len_user */
209                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      // len_password                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
210                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      // Length of BLOB                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
211                          2 +     // len_program                          2 +     /* len_program */
212                          2 +     // len_directory                          2 +     /* len_directory */
213                          (0 < len_domain ? len_domain : 2) +     // domain                          (0 < len_domain ? len_domain : 2) +     /* domain */
214                          len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    // We have no 512 byte BLOB. Perhaps we must?                          len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
215                          (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + // After the BLOB is a unknown int16. If there is a BLOB, that is.                          (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
216                          (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     // Unknown (2)                          (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
217                          2 +     // Client ip length                          2 +     /* Client ip length */
218                          len_ip +        // Client ip                          len_ip +        /* Client ip */
219                          2 +     // DLL string length                          2 +     /* DLL string length */
220                          len_dll +       // DLL string                          len_dll +       /* DLL string */
221                          2 +     // Unknown                          2 +     /* Unknown */
222                          2 +     // Unknown                          2 +     /* Unknown */
223                          64 +    // Time zone #0                          64 +    /* Time zone #0 */
224                          2 +     // Unknown                          2 +     /* Unknown */
225                          64 +    // Time zone #1                          64 +    /* Time zone #1 */
226                          32;     // Unknown                          32;     /* Unknown */
227    
228                  s = sec_init(sec_flags, packetlen);                  s = sec_init(sec_flags, packetlen);
229                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
230    
231                  out_uint32(s, 0);       // Unknown                  out_uint32(s, 0);       /* Unknown */
232                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
233                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
234                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
# Line 243  rdp_send_logon_info(uint32 flags, char * Line 274  rdp_send_logon_info(uint32 flags, char *
274                          out_uint16_le(s, 0);                          out_uint16_le(s, 0);
275                  }                  }
276                  out_uint16_le(s, 2);                  out_uint16_le(s, 2);
277                  out_uint16_le(s, len_ip + 2);   // Length of client ip                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
278                  rdp_out_unistr(s, "127.0.0.1", len_ip);                  rdp_out_unistr(s, ipaddr, len_ip);
279                  out_uint16_le(s, len_dll + 2);                  out_uint16_le(s, len_dll + 2);
280                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
281                  out_uint16_le(s, 0xffc4);  
282                  out_uint16_le(s, 0xffff);                  tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
283                    out_uint32_le(s, tzone);
284    
285                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
286                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
287    
   
288                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
289                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
290                  out_uint32_le(s, 3);                  out_uint32_le(s, 3);
# Line 268  rdp_send_logon_info(uint32 flags, char * Line 300  rdp_send_logon_info(uint32 flags, char *
300                  out_uint32(s, 0);                  out_uint32(s, 0);
301                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
302                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
303                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
304                  out_uint32(s, 0);                  out_uint32(s, 0);
305    
306    
# Line 338  rdp_send_fonts(uint16 seq) Line 370  rdp_send_fonts(uint16 seq)
370          s = rdp_init_data(8);          s = rdp_init_data(8);
371    
372          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
373          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
374          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
375          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
376    
# Line 358  rdp_out_general_caps(STREAM s) Line 390  rdp_out_general_caps(STREAM s)
390          out_uint16_le(s, 0x200);        /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
391          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
392          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
393          out_uint16_le(s, use_rdp5 ? 0x40d : 0);          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
394          /* Pad, according to T.128. 0x40d seems to          /* Pad, according to T.128. 0x40d seems to
395             trigger             trigger
396             the server to start sending RDP5 packets.             the server to start sending RDP5 packets.
# Line 379  rdp_out_bitmap_caps(STREAM s) Line 411  rdp_out_bitmap_caps(STREAM s)
411          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
412          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
413    
414          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
415          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
416          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
417          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
418          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
419          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
420          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
421          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
422          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
423          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
424          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
425          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
# Line 408  rdp_out_order_caps(STREAM s) Line 440  rdp_out_order_caps(STREAM s)
440          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
441          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
442          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
443          order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
444          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
445          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
446          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
# Line 426  rdp_out_order_caps(STREAM s) Line 458  rdp_out_order_caps(STREAM s)
458          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
459          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
460          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
461          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 */
462          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
463          out_uint32_le(s, 0x4e4);        /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
464  }  }
# Line 439  rdp_out_bmpcache_caps(STREAM s) Line 471  rdp_out_bmpcache_caps(STREAM s)
471          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
472          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
473    
474          Bpp = (server_bpp + 7) / 8;          Bpp = (g_server_bpp + 7) / 8;
475          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
476          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
477          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
# Line 546  static void Line 578  static void
578  rdp_send_confirm_active(void)  rdp_send_confirm_active(void)
579  {  {
580          STREAM s;          STREAM s;
581          uint32 sec_flags = encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;          uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
582          uint16 caplen =          uint16 caplen =
583                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
584                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
# Line 559  rdp_send_confirm_active(void) Line 591  rdp_send_confirm_active(void)
591          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
592          out_uint16_le(s, (g_mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
593    
594          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
595          out_uint16_le(s, 0x3ea);        /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
596          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
597          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
# Line 583  rdp_send_confirm_active(void) Line 615  rdp_send_confirm_active(void)
615          sec_send(s, sec_flags);          sec_send(s, sec_flags);
616  }  }
617    
618    /* Process a general capability set */
619    static void
620    rdp_process_general_caps(STREAM s)
621    {
622            uint16 pad2octetsB;     /* rdp5 flags? */
623    
624            in_uint8s(s, 10);
625            in_uint16_le(s, pad2octetsB);
626    
627            if (!pad2octetsB)
628                    g_use_rdp5 = False;
629    }
630    
631    /* Process a bitmap capability set */
632    static void
633    rdp_process_bitmap_caps(STREAM s)
634    {
635            uint16 width, height, bpp;
636    
637            in_uint16_le(s, bpp);
638            in_uint8s(s, 6);
639    
640            in_uint16_le(s, width);
641            in_uint16_le(s, height);
642    
643            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
644    
645            /*
646             * The server may limit bpp and change the size of the desktop (for
647             * example when shadowing another session).
648             */
649            g_server_bpp = bpp;
650            g_width = width;
651            g_height = height;
652    
653            ui_resize_window();
654    }
655    
656  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
657  static void  static void
658  process_demand_active(STREAM s)  process_demand_active(STREAM s)
659  {  {
660          uint8 type;          int n;
661            uint8 type, *next;
662            uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;
663    
664            in_uint32_le(s, g_rdp_shareid);
665            in_uint16_le(s, len_src_descriptor);
666            in_uint16_le(s, len_combined_caps);
667            in_uint8s(s, len_src_descriptor);
668    
669            in_uint16_le(s, num_capsets);
670            in_uint8s(s, 2);        /* pad */
671    
672            DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));
673    
674            for (n = 0; n < num_capsets; n++)
675            {
676                    in_uint16_le(s, capset_type);
677                    in_uint16_le(s, capset_length);
678    
679          in_uint32_le(s, rdp_shareid);                  next = s->p + capset_length - 4;
680    
681          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));                  switch (capset_type)
682                    {
683                            case RDP_CAPSET_GENERAL:
684                                    rdp_process_general_caps(s);
685                                    break;
686    
687                            case RDP_CAPSET_BITMAP:
688                                    rdp_process_bitmap_caps(s);
689                                    break;
690                    }
691    
692                    s->p = next;
693            }
694    
695          rdp_send_confirm_active();          rdp_send_confirm_active();
696          rdp_send_synchronise();          rdp_send_synchronise();
# Line 600  process_demand_active(STREAM s) Line 699  process_demand_active(STREAM s)
699          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
700          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
701          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
702          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();  
 }  
703    
704  /* Process a null system pointer PDU */          if (g_use_rdp5)
705  void          {
706  process_null_system_pointer_pdu(STREAM s)                  rdp_send_fonts(3);
707  {          }
708          // FIXME: We should probably set another cursor here,          else
709          // like the X window system base cursor or something.          {
710          ui_set_cursor(cache_get_cursor(0));                  rdp_send_fonts(1);
711                    rdp_send_fonts(2);
712            }
713    
714            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
715            reset_order_state();
716  }  }
717    
718  /* Process a colour pointer PDU */  /* Process a colour pointer PDU */
# Line 648  process_cached_pointer_pdu(STREAM s) Line 747  process_cached_pointer_pdu(STREAM s)
747          ui_set_cursor(cache_get_cursor(cache_idx));          ui_set_cursor(cache_get_cursor(cache_idx));
748  }  }
749    
750    /* Process a system pointer PDU */
751    void
752    process_system_pointer_pdu(STREAM s)
753    {
754            uint16 system_pointer_type;
755    
756            in_uint16(s, system_pointer_type);
757            switch (system_pointer_type)
758            {
759                    case RDP_NULL_POINTER:
760                            ui_set_null_cursor();
761                            break;
762    
763                    default:
764                            unimpl("System pointer message 0x%x\n", system_pointer_type);
765            }
766    }
767    
768  /* Process a pointer PDU */  /* Process a pointer PDU */
769  static void  static void
# Line 676  process_pointer_pdu(STREAM s) Line 792  process_pointer_pdu(STREAM s)
792                          process_cached_pointer_pdu(s);                          process_cached_pointer_pdu(s);
793                          break;                          break;
794    
795                    case RDP_POINTER_SYSTEM:
796                            process_system_pointer_pdu(s);
797                            break;
798    
799                  default:                  default:
800                          DEBUG(("Pointer message 0x%x\n", message_type));                          unimpl("Pointer message 0x%x\n", message_type);
801          }          }
802  }  }
803    
# Line 817  process_update_pdu(STREAM s) Line 937  process_update_pdu(STREAM s)
937    
938  }  }
939    
940    /* Process a disconnect PDU */
941    void
942    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
943    {
944            in_uint32_le(s, *ext_disc_reason);
945    
946            DEBUG(("Received disconnect PDU\n"));
947    }
948    
949  /* Process data PDU */  /* Process data PDU */
950  static void  static BOOL
951  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
952  {  {
953          uint8 data_pdu_type;          uint8 data_pdu_type;
954            uint8 ctype;
955            uint16 clen;
956            int len;
957    #if 0
958            int roff, rlen, ret;
959            static struct stream ns;
960            static signed char *dict = 0;
961    #endif
962    
963          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          in_uint8s(s, 6);        /* shareid, pad, streamid */
964            in_uint16(s, len);
965          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
966          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
967            in_uint16(s, clen);
968            clen -= 18;
969    
970    #if 0
971            if (ctype & 0x20)
972            {
973                    if (!dict)
974                    {
975                            dict = (signed char *) malloc(8200 * sizeof(signed char));
976                            dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));
977                    }
978    
979                    ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);
980    
981                    len -= 18;
982    
983                    ns.data = xrealloc(ns.data, len);
984    
985                    ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);
986    
987                    ns.size = len;
988                    ns.end = ns.data + ns.size;
989                    ns.p = ns.data;
990                    ns.rdp_hdr = ns.p;
991    
992                    s = &ns;
993            }
994    #endif
995    
996          switch (data_pdu_type)          switch (data_pdu_type)
997          {          {
# Line 833  process_data_pdu(STREAM s) Line 999  process_data_pdu(STREAM s)
999                          process_update_pdu(s);                          process_update_pdu(s);
1000                          break;                          break;
1001    
1002                    case RDP_DATA_PDU_CONTROL:
1003                            DEBUG(("Received Control PDU\n"));
1004                            break;
1005    
1006                    case RDP_DATA_PDU_SYNCHRONISE:
1007                            DEBUG(("Received Sync PDU\n"));
1008                            break;
1009    
1010                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1011                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1012                          break;                          break;
# Line 846  process_data_pdu(STREAM s) Line 1020  process_data_pdu(STREAM s)
1020                          /* User logged on */                          /* User logged on */
1021                          break;                          break;
1022    
1023                    case RDP_DATA_PDU_DISCONNECT:
1024                            process_disconnect_pdu(s, ext_disc_reason);
1025                            return True;
1026    
1027                  default:                  default:
1028                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1029          }          }
1030            return False;
1031  }  }
1032    
1033  /* Process incoming packets */  /* Process incoming packets */
1034  BOOL  void
1035  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1036  {  {
1037          uint8 type;          uint8 type;
1038            BOOL disc = False;      /* True when a disconnect PDU was received */
1039          STREAM s;          STREAM s;
1040    
1041          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 864  rdp_main_loop(void) Line 1044  rdp_main_loop(void)
1044                  {                  {
1045                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1046                                  process_demand_active(s);                                  process_demand_active(s);
1047                                    *deactivated = False;
1048                                  break;                                  break;
1049    
1050                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1051                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1052                                  /* We thought we could detect a clean                                  *deactivated = True;
                                    shutdown of the session by this  
                                    packet, but it seems Windows 2003  
                                    is sending us one of these when we  
                                    reconnect to a disconnected session  
                                    return True; */  
1053                                  break;                                  break;
1054    
1055                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1056                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1057                                  break;                                  break;
1058    
1059                          case 0:                          case 0:
# Line 886  rdp_main_loop(void) Line 1062  rdp_main_loop(void)
1062                          default:                          default:
1063                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1064                  }                  }
1065    
1066                    if (disc)
1067                    {
1068                            return;
1069                    }
1070          }          }
1071          return True;          return;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1072  }  }
1073    
1074  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
# Line 898  BOOL Line 1076  BOOL
1076  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1077              char *command, char *directory)              char *command, char *directory)
1078  {  {
1079          if (!sec_connect(server, username))          if (!sec_connect(server, g_username))
1080                  return False;                  return False;
1081    
1082          rdp_send_logon_info(flags, domain, username, password, command, directory);          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1083          return True;          return True;
1084  }  }
1085    
Legend:
Removed from v.436  
changed lines
  Added in v.677
  ViewVC Help
Powered by ViewVC 1.1.26