/[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 676 by astrand, Tue Apr 20 07:01:21 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    
35  uint8 *next_packet;  uint8 *g_next_packet;
36  uint32 rdp_shareid;  uint32 g_rdp_shareid;
37    
38  #if WITH_DEBUG  #if WITH_DEBUG
39  static uint32 packetno;  static uint32 g_packetno;
40  #endif  #endif
41    
42  /* Receive an RDP packet */  /* Receive an RDP packet */
# Line 44  rdp_recv(uint8 * type) Line 46  rdp_recv(uint8 * type)
46          static STREAM rdp_s;          static STREAM rdp_s;
47          uint16 length, pdu_type;          uint16 length, pdu_type;
48    
49          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
50          {          {
51                  rdp_s = sec_recv();                  rdp_s = sec_recv();
52                  if (rdp_s == NULL)                  if (rdp_s == NULL)
53                          return NULL;                          return NULL;
54    
55                  next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
56          }          }
57          else          else
58          {          {
59                  rdp_s->p = next_packet;                  rdp_s->p = g_next_packet;
60          }          }
61    
62          in_uint16_le(rdp_s, length);          in_uint16_le(rdp_s, length);
63          /* 32k packets are really 8, keepalive fix */          /* 32k packets are really 8, keepalive fix */
64          if (length == 0x8000)          if (length == 0x8000)
65          {          {
66                  next_packet += 8;                  g_next_packet += 8;
67                  *type = 0;                  *type = 0;
68                  return rdp_s;                  return rdp_s;
69          }          }
# Line 70  rdp_recv(uint8 * type) Line 72  rdp_recv(uint8 * type)
72          *type = pdu_type & 0xf;          *type = pdu_type & 0xf;
73    
74  #if WITH_DEBUG  #if WITH_DEBUG
75          DEBUG(("RDP packet #%d, (type %x)\n", ++packetno, *type));          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
76          //      hexdump(next_packet, length);          hexdump(g_next_packet, length);
77  #endif /*  */  #endif /*  */
78    
79          next_packet += length;          g_next_packet += length;
80          return rdp_s;          return rdp_s;
81  }  }
82    
# Line 84  rdp_init_data(int maxlen) Line 86  rdp_init_data(int maxlen)
86  {  {
87          STREAM s;          STREAM s;
88    
89          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
90          s_push_layer(s, rdp_hdr, 18);          s_push_layer(s, rdp_hdr, 18);
91    
92          return s;          return s;
# Line 103  rdp_send_data(STREAM s, uint8 data_pdu_t Line 105  rdp_send_data(STREAM s, uint8 data_pdu_t
105          out_uint16_le(s, (RDP_PDU_DATA | 0x10));          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
106          out_uint16_le(s, (g_mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
107    
108          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
109          out_uint8(s, 0);        /* pad */          out_uint8(s, 0);        /* pad */
110          out_uint8(s, 1);        /* streamid */          out_uint8(s, 1);        /* streamid */
111          out_uint16_le(s, (length - 14));          out_uint16_le(s, (length - 14));
# Line 111  rdp_send_data(STREAM s, uint8 data_pdu_t Line 113  rdp_send_data(STREAM s, uint8 data_pdu_t
113          out_uint8(s, 0);        /* compress_type */          out_uint8(s, 0);        /* compress_type */
114          out_uint16(s, 0);       /* compress_len */          out_uint16(s, 0);       /* compress_len */
115    
116          sec_send(s, encryption ? SEC_ENCRYPT : 0);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
117  }  }
118    
119  /* Output a string in Unicode */  /* Output a string in Unicode */
# Line 131  rdp_out_unistr(STREAM s, char *string, i Line 133  rdp_out_unistr(STREAM s, char *string, i
133          s->p += len;          s->p += len;
134  }  }
135    
136    /* Input a string in Unicode
137     *
138     * Returns str_len of string
139     */
140    int
141    rdp_in_unistr(STREAM s, char *string, int uni_len)
142    {
143            int i = 0;
144    
145            while (i < uni_len / 2)
146            {
147                    in_uint8a(s, &string[i++], 1);
148                    in_uint8s(s, 1);
149            }
150    
151            return i - 1;
152    }
153    
154    
155  /* Parse a logon info packet */  /* Parse a logon info packet */
156  static void  static void
157  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
158                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
159  {  {
160            char *ipaddr = tcp_get_address();
161          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
162          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
163          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
164          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
165          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
166          int len_ip = 2 * strlen("127.0.0.1");          int len_ip = 2 * strlen(ipaddr);
167          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
168          int packetlen = 0;          int packetlen = 0;
169          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;
170          STREAM s;          STREAM s;
171            time_t t = time(NULL);
172            time_t tzone;
173    
174          if (!use_rdp5 || 1 == server_rdp_version)  #if 0
175            // enable rdp compression
176            flags |= RDP_COMPRESSION;
177    #endif
178    
179            if (!g_use_rdp5 || 1 == g_server_rdp_version)
180          {          {
181                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
182    
# Line 171  rdp_send_logon_info(uint32 flags, char * Line 200  rdp_send_logon_info(uint32 flags, char *
200          {          {
201                  flags |= RDP_LOGON_BLOB;                  flags |= RDP_LOGON_BLOB;
202                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
203                  packetlen = 4 + // Unknown uint32                  packetlen = 4 + /* Unknown uint32 */
204                          4 +     // flags                          4 +     /* flags */
205                          2 +     // len_domain                          2 +     /* len_domain */
206                          2 +     // len_user                          2 +     /* len_user */
207                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      // len_password                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
208                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      // Length of BLOB                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
209                          2 +     // len_program                          2 +     /* len_program */
210                          2 +     // len_directory                          2 +     /* len_directory */
211                          (0 < len_domain ? len_domain : 2) +     // domain                          (0 < len_domain ? len_domain : 2) +     /* domain */
212                          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? */
213                          (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. */
214                          (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) */
215                          2 +     // Client ip length                          2 +     /* Client ip length */
216                          len_ip +        // Client ip                          len_ip +        /* Client ip */
217                          2 +     // DLL string length                          2 +     /* DLL string length */
218                          len_dll +       // DLL string                          len_dll +       /* DLL string */
219                          2 +     // Unknown                          2 +     /* Unknown */
220                          2 +     // Unknown                          2 +     /* Unknown */
221                          64 +    // Time zone #0                          64 +    /* Time zone #0 */
222                          2 +     // Unknown                          2 +     /* Unknown */
223                          64 +    // Time zone #1                          64 +    /* Time zone #1 */
224                          32;     // Unknown                          32;     /* Unknown */
225    
226                  s = sec_init(sec_flags, packetlen);                  s = sec_init(sec_flags, packetlen);
227                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
228    
229                  out_uint32(s, 0);       // Unknown                  out_uint32(s, 0);       /* Unknown */
230                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
231                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
232                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
# Line 243  rdp_send_logon_info(uint32 flags, char * Line 272  rdp_send_logon_info(uint32 flags, char *
272                          out_uint16_le(s, 0);                          out_uint16_le(s, 0);
273                  }                  }
274                  out_uint16_le(s, 2);                  out_uint16_le(s, 2);
275                  out_uint16_le(s, len_ip + 2);   // Length of client ip                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
276                  rdp_out_unistr(s, "127.0.0.1", len_ip);                  rdp_out_unistr(s, ipaddr, len_ip);
277                  out_uint16_le(s, len_dll + 2);                  out_uint16_le(s, len_dll + 2);
278                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
279                  out_uint16_le(s, 0xffc4);  
280                  out_uint16_le(s, 0xffff);                  tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
281                    out_uint32_le(s, tzone);
282    
283                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
284                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
285    
   
286                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
287                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
288                  out_uint32_le(s, 3);                  out_uint32_le(s, 3);
# Line 268  rdp_send_logon_info(uint32 flags, char * Line 298  rdp_send_logon_info(uint32 flags, char *
298                  out_uint32(s, 0);                  out_uint32(s, 0);
299                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
300                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
301                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
302                  out_uint32(s, 0);                  out_uint32(s, 0);
303    
304    
# Line 358  rdp_out_general_caps(STREAM s) Line 388  rdp_out_general_caps(STREAM s)
388          out_uint16_le(s, 0x200);        /* Protocol version */          out_uint16_le(s, 0x200);        /* Protocol version */
389          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
390          out_uint16(s, 0);       /* Compression types */          out_uint16(s, 0);       /* Compression types */
391          out_uint16_le(s, use_rdp5 ? 0x40d : 0);          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
392          /* Pad, according to T.128. 0x40d seems to          /* Pad, according to T.128. 0x40d seems to
393             trigger             trigger
394             the server to start sending RDP5 packets.             the server to start sending RDP5 packets.
# Line 379  rdp_out_bitmap_caps(STREAM s) Line 409  rdp_out_bitmap_caps(STREAM s)
409          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
410          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
411    
412          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
413          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
414          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
415          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
# Line 387  rdp_out_bitmap_caps(STREAM s) Line 417  rdp_out_bitmap_caps(STREAM s)
417          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
418          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
419          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 0);       /* Allow resize */
420          out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
421          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
422          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
423          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
# Line 408  rdp_out_order_caps(STREAM s) Line 438  rdp_out_order_caps(STREAM s)
438          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
439          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
440          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
441          order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */          order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
442          order_caps[13] = 1;     /* memblt */          order_caps[13] = 1;     /* memblt */
443          order_caps[14] = 1;     /* triblt */          order_caps[14] = 1;     /* triblt */
444          order_caps[22] = 1;     /* polyline */          order_caps[22] = 1;     /* polyline */
# Line 426  rdp_out_order_caps(STREAM s) Line 456  rdp_out_order_caps(STREAM s)
456          out_uint8p(s, order_caps, 32);  /* Orders supported */          out_uint8p(s, order_caps, 32);  /* Orders supported */
457          out_uint16_le(s, 0x6a1);        /* Text capability flags */          out_uint16_le(s, 0x6a1);        /* Text capability flags */
458          out_uint8s(s, 6);       /* Pad */          out_uint8s(s, 6);       /* Pad */
459          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 */
460          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
461          out_uint32_le(s, 0x4e4);        /* Unknown */          out_uint32_le(s, 0x4e4);        /* Unknown */
462  }  }
# Line 439  rdp_out_bmpcache_caps(STREAM s) Line 469  rdp_out_bmpcache_caps(STREAM s)
469          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
470          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
471    
472          Bpp = (server_bpp + 7) / 8;          Bpp = (g_server_bpp + 7) / 8;
473          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
474          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
475          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
# Line 546  static void Line 576  static void
576  rdp_send_confirm_active(void)  rdp_send_confirm_active(void)
577  {  {
578          STREAM s;          STREAM s;
579          uint32 sec_flags = encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;          uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
580          uint16 caplen =          uint16 caplen =
581                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
582                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
# Line 559  rdp_send_confirm_active(void) Line 589  rdp_send_confirm_active(void)
589          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */          out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
590          out_uint16_le(s, (g_mcs_userid + 1001));          out_uint16_le(s, (g_mcs_userid + 1001));
591    
592          out_uint32_le(s, rdp_shareid);          out_uint32_le(s, g_rdp_shareid);
593          out_uint16_le(s, 0x3ea);        /* userid */          out_uint16_le(s, 0x3ea);        /* userid */
594          out_uint16_le(s, sizeof(RDP_SOURCE));          out_uint16_le(s, sizeof(RDP_SOURCE));
595          out_uint16_le(s, caplen);          out_uint16_le(s, caplen);
# Line 588  static void Line 618  static void
618  process_demand_active(STREAM s)  process_demand_active(STREAM s)
619  {  {
620          uint8 type;          uint8 type;
621            uint16 i;
622            uint16 p_bpp;
623    
624          in_uint32_le(s, rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
625    
626          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));          /* scan for prefered bpp */
627            while (s_check_rem(s, 6))
628            {
629                    in_uint16_le(s, i);
630                    if (i == RDP_CAPSET_BITMAP)
631                    {
632                            in_uint16_le(s, i);
633                            if (i == RDP_CAPLEN_BITMAP)
634                            {
635                                    in_uint16_le(s, p_bpp);
636                                    if (p_bpp == 8 || p_bpp == 15 || p_bpp == 16 || p_bpp == 24)
637                                    {
638                                            if (p_bpp < g_server_bpp)
639                                            {
640                                                    warning("Server limited colour depth to %d bits\n",
641                                                            p_bpp);
642                                                    g_server_bpp = p_bpp;
643                                            }
644                                            break;
645                                    }
646                            }
647                    }
648            }
649    
650    
651            DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
652    
653          rdp_send_confirm_active();          rdp_send_confirm_active();
654          rdp_send_synchronise();          rdp_send_synchronise();
# Line 600  process_demand_active(STREAM s) Line 657  process_demand_active(STREAM s)
657          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
658          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
659          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
660          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);
661          rdp_send_fonts(1);          rdp_send_fonts(1);
662          rdp_send_fonts(2);          rdp_send_fonts(2);
663          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
664          reset_order_state();          reset_order_state();
665  }  }
666    
 /* Process a null system pointer PDU */  
 void  
 process_null_system_pointer_pdu(STREAM s)  
 {  
         // FIXME: We should probably set another cursor here,  
         // like the X window system base cursor or something.  
         ui_set_cursor(cache_get_cursor(0));  
 }  
   
667  /* Process a colour pointer PDU */  /* Process a colour pointer PDU */
668  void  void
669  process_colour_pointer_pdu(STREAM s)  process_colour_pointer_pdu(STREAM s)
# Line 648  process_cached_pointer_pdu(STREAM s) Line 696  process_cached_pointer_pdu(STREAM s)
696          ui_set_cursor(cache_get_cursor(cache_idx));          ui_set_cursor(cache_get_cursor(cache_idx));
697  }  }
698    
699    /* Process a system pointer PDU */
700    void
701    process_system_pointer_pdu(STREAM s)
702    {
703            uint16 system_pointer_type;
704    
705            in_uint16(s, system_pointer_type);
706            switch (system_pointer_type)
707            {
708                    case RDP_NULL_POINTER:
709                            ui_set_null_cursor();
710                            break;
711    
712                    default:
713                            unimpl("System pointer message 0x%x\n", system_pointer_type);
714            }
715    }
716    
717  /* Process a pointer PDU */  /* Process a pointer PDU */
718  static void  static void
# Line 676  process_pointer_pdu(STREAM s) Line 741  process_pointer_pdu(STREAM s)
741                          process_cached_pointer_pdu(s);                          process_cached_pointer_pdu(s);
742                          break;                          break;
743    
744                    case RDP_POINTER_SYSTEM:
745                            process_system_pointer_pdu(s);
746                            break;
747    
748                  default:                  default:
749                          DEBUG(("Pointer message 0x%x\n", message_type));                          unimpl("Pointer message 0x%x\n", message_type);
750          }          }
751  }  }
752    
# Line 817  process_update_pdu(STREAM s) Line 886  process_update_pdu(STREAM s)
886    
887  }  }
888    
889    /* Process a disconnect PDU */
890    void
891    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
892    {
893            in_uint32_le(s, *ext_disc_reason);
894    
895            DEBUG(("Received disconnect PDU\n"));
896    }
897    
898  /* Process data PDU */  /* Process data PDU */
899  static void  static BOOL
900  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
901  {  {
902          uint8 data_pdu_type;          uint8 data_pdu_type;
903            uint8 ctype;
904            uint16 clen;
905            int len;
906    #if 0
907            int roff, rlen, ret;
908            static struct stream ns;
909            static signed char *dict = 0;
910    #endif
911    
912          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          in_uint8s(s, 6);        /* shareid, pad, streamid */
913            in_uint16(s, len);
914          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
915          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
916            in_uint16(s, clen);
917            clen -= 18;
918    
919    #if 0
920            if (ctype & 0x20)
921            {
922                    if (!dict)
923                    {
924                            dict = (signed char *) malloc(8200 * sizeof(signed char));
925                            dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));
926                    }
927    
928                    ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);
929    
930                    len -= 18;
931    
932                    ns.data = xrealloc(ns.data, len);
933    
934                    ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);
935    
936                    ns.size = len;
937                    ns.end = ns.data + ns.size;
938                    ns.p = ns.data;
939                    ns.rdp_hdr = ns.p;
940    
941                    s = &ns;
942            }
943    #endif
944    
945          switch (data_pdu_type)          switch (data_pdu_type)
946          {          {
# Line 833  process_data_pdu(STREAM s) Line 948  process_data_pdu(STREAM s)
948                          process_update_pdu(s);                          process_update_pdu(s);
949                          break;                          break;
950    
951                    case RDP_DATA_PDU_CONTROL:
952                            DEBUG(("Received Control PDU\n"));
953                            break;
954    
955                    case RDP_DATA_PDU_SYNCHRONISE:
956                            DEBUG(("Received Sync PDU\n"));
957                            break;
958    
959                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
960                          process_pointer_pdu(s);                          process_pointer_pdu(s);
961                          break;                          break;
# Line 846  process_data_pdu(STREAM s) Line 969  process_data_pdu(STREAM s)
969                          /* User logged on */                          /* User logged on */
970                          break;                          break;
971    
972                    case RDP_DATA_PDU_DISCONNECT:
973                            process_disconnect_pdu(s, ext_disc_reason);
974                            return True;
975    
976                  default:                  default:
977                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
978          }          }
979            return False;
980  }  }
981    
982  /* Process incoming packets */  /* Process incoming packets */
983  BOOL  void
984  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
985  {  {
986          uint8 type;          uint8 type;
987            BOOL disc = False;      /* True when a disconnect PDU was received */
988          STREAM s;          STREAM s;
989    
990          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 864  rdp_main_loop(void) Line 993  rdp_main_loop(void)
993                  {                  {
994                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
995                                  process_demand_active(s);                                  process_demand_active(s);
996                                    *deactivated = False;
997                                  break;                                  break;
998    
999                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1000                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  *deactivated = True;
                                 /* We thought we could detect a clean  
                                    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; */  
1001                                  break;                                  break;
1002    
1003                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1004                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1005                                  break;                                  break;
1006    
1007                          case 0:                          case 0:
# Line 886  rdp_main_loop(void) Line 1010  rdp_main_loop(void)
1010                          default:                          default:
1011                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1012                  }                  }
1013    
1014                    if (disc)
1015                    {
1016                            return;
1017                    }
1018          }          }
1019          return True;          return;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1020  }  }
1021    
1022  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
# Line 898  BOOL Line 1024  BOOL
1024  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1025              char *command, char *directory)              char *command, char *directory)
1026  {  {
1027          if (!sec_connect(server, username))          if (!sec_connect(server, g_username))
1028                  return False;                  return False;
1029    
1030          rdp_send_logon_info(flags, domain, username, password, command, directory);          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1031          return True;          return True;
1032  }  }
1033    
Legend:
Removed from v.436  
changed lines
  Added in v.676
  ViewVC Help
Powered by ViewVC 1.1.26