/[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 7 by matty, Fri Jul 7 09:40:03 2000 UTC revision 554 by stargo, Tue Dec 9 09:57:44 2003 UTC
# Line 1  Line 1 
1  /*  /* -*- c-basic-offset: 8 -*-
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     Protocol services - RDP layer     Protocol services - RDP layer
4     Copyright (C) Matthew Chapman 1999-2000     Copyright (C) Matthew Chapman 1999-2002
5      
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.     (at your option) any later version.
10      
11     This program is distributed in the hope that it will be useful,     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.     GNU General Public License for more details.
15      
16     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */  */
20    
21  #include "includes.h"  #include <time.h>
22    #include "rdesktop.h"
 /* Establish a connection up to the RDP layer */  
 HCONN rdp_connect(char *server)  
 {  
         HCONN conn;  
         RDP_ACTIVE_PDU active;  
         uint8 type;  
   
         if ((conn = mcs_connect(server)) == NULL)  
                 return NULL;  
   
         rdp_establish_key(conn);  
         mcs_recv(conn, False); /* Server's licensing certificate */  
         rdp_send_cert(conn);  
         mcs_recv(conn, False);  
         mcs_recv(conn, False); /* Demand active */  
23    
24          if (!rdp_recv_pdu(conn, &type) || (type != RDP_PDU_DEMAND_ACTIVE))  extern uint16 g_mcs_userid;
25          {  extern char g_username[16];
26                  fprintf(stderr, "RDP error, expected Demand Active\n");  extern BOOL g_bitmap_compression;
27                  mcs_disconnect(conn);  extern BOOL g_orders;
28                  return NULL;  extern BOOL g_encryption;
29          }  extern BOOL g_desktop_save;
30    extern BOOL g_use_rdp5;
31    extern uint16 g_server_rdp_version;
32    extern int g_server_bpp;
33    extern time_t timezone;
34    
35          rdp_io_active_pdu(&conn->in, &active, RDP_PDU_DEMAND_ACTIVE);  uint8 *g_next_packet;
36          rdp_send_confirm_active(conn);  uint32 g_rdp_shareid;
         rdp_send_synchronize(conn);  
         rdp_send_control(conn, RDP_CTL_COOPERATE);  
         rdp_send_control(conn, RDP_CTL_REQUEST_CONTROL);  
         rdp_recv_pdu(conn, &type); // RDP_PDU_SYNCHRONIZE  
         rdp_recv_pdu(conn, &type); // RDP_CTL_COOPERATE  
         rdp_recv_pdu(conn, &type); // RDP_CTL_GRANT_CONTROL  
         rdp_send_input(conn);  
         rdp_send_fonts(conn, 1);  
         rdp_send_fonts(conn, 2);  
         rdp_recv_pdu(conn, &type); // RDP_PDU_UNKNOWN 0x28  
37    
38          return conn;  #if WITH_DEBUG
39  }  static uint32 g_packetno;
40    #endif
41    
42  void rdp_main_loop(HCONN conn)  /* Receive an RDP packet */
43    static STREAM
44    rdp_recv(uint8 * type)
45  {  {
46          RDP_DATA_HEADER hdr;          static STREAM rdp_s;
47          RDP_ORDER_STATE os;          uint16 length, pdu_type;
         uint8 type;  
   
         memset(&os, 0, sizeof(os));  
48    
49          while (rdp_recv_pdu(conn, &type))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
50          {          {
51                  if (type != RDP_PDU_DATA)                  rdp_s = sec_recv();
52                  {                  if (rdp_s == NULL)
53                          fprintf(stderr, "Unknown PDU 0x%x\n", type);                          return NULL;
                         continue;  
                 }  
54    
55                  rdp_io_data_header(&conn->in, &hdr);                  g_next_packet = rdp_s->p;
   
                 switch (hdr.data_pdu_type)  
                 {  
                         case RDP_DATA_PDU_UPDATE:  
                                 process_update(conn, &os);  
                                 break;  
   
                         case RDP_DATA_PDU_POINTER:  
                                 process_pointer(conn);  
                                 break;  
   
                         default:  
                                 fprintf(stderr, "Unknown data PDU 0x%x\n",  
                                                 hdr.data_pdu_type);  
                 }  
56          }          }
57  }          else
   
 void process_memblt(HCONN conn, RDP_ORDER_STATE *os, BOOL delta)  
 {  
         HBITMAP hbitmap;  
         uint16 present;  
         lsb_io_uint16(&conn->in, &present);  
   
         if (present & 1)  
                 prs_io_uint8(&conn->in, &os->memblt.cache_id);  
   
         if (present & 2)  
                 rdp_io_coord(&conn->in, &os->memblt.x, delta);  
   
         if (present & 4)  
                 rdp_io_coord(&conn->in, &os->memblt.y, delta);  
   
         if (present & 8)  
                 rdp_io_coord(&conn->in, &os->memblt.cx, delta);  
   
         if (present & 16)  
                 rdp_io_coord(&conn->in, &os->memblt.cy, delta);  
   
         if (present & 32)  
                 prs_io_uint8(&conn->in, &os->memblt.opcode);  
   
         if (present & 256)  
                 lsb_io_uint16(&conn->in, &os->memblt.cache_idx);  
   
         if (os->memblt.opcode != 0xcc) /* SRCCOPY */  
58          {          {
59                  fprintf(stderr, "Unsupported raster operation 0x%x\n",                  rdp_s->p = g_next_packet;
                         os->memblt.opcode);  
                 return;  
60          }          }
61    
62          if ((os->memblt.cache_idx > NUM_ELEMENTS(conn->bmpcache))          in_uint16_le(rdp_s, length);
63              || ((hbitmap = conn->bmpcache[os->memblt.cache_idx]) == NULL))          /* 32k packets are really 8, keepalive fix */
64            if (length == 0x8000)
65          {          {
66                  fprintf(stderr, "Bitmap %d not found\n", os->memblt.cache_idx);                  g_next_packet += 8;
67                  return;                  *type = 0;
68                    return rdp_s;
69          }          }
70            in_uint16_le(rdp_s, pdu_type);
71            in_uint8s(rdp_s, 2);    /* userid */
72            *type = pdu_type & 0xf;
73    
74          fprintf(stderr, "MEMBLT %d:%dx%d\n", os->memblt.cache_idx,  #if WITH_DEBUG
75                                          os->memblt.x, os->memblt.y);          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
76            hexdump(g_next_packet, length);
77    #endif /*  */
78    
79          ui_paint_bitmap(conn->wnd, hbitmap, os->memblt.x, os->memblt.y);          g_next_packet += length;
80            return rdp_s;
81  }  }
82    
83  void process_opaque_rect(HCONN conn, RDP_ORDER_STATE *os, BOOL delta)  /* Initialise an RDP data packet */
84    static STREAM
85    rdp_init_data(int maxlen)
86  {  {
87          uint8 present;          STREAM s;
         prs_io_uint8(&conn->in, &present);  
88    
89          if (present & 1)          s = sec_init(g_encryption ? SEC_ENCRYPT : 0, maxlen + 18);
90                  rdp_io_coord(&conn->in, &os->opaque_rect.x, delta);          s_push_layer(s, rdp_hdr, 18);
91    
92          if (present & 2)          return s;
93                  rdp_io_coord(&conn->in, &os->opaque_rect.y, delta);  }
94    
95          if (present & 4)  /* Send an RDP data packet */
96                  rdp_io_coord(&conn->in, &os->opaque_rect.cx, delta);  static void
97    rdp_send_data(STREAM s, uint8 data_pdu_type)
98    {
99            uint16 length;
100    
101            s_pop_layer(s, rdp_hdr);
102            length = s->end - s->p;
103    
104          if (present & 8)          out_uint16_le(s, length);
105                  rdp_io_coord(&conn->in, &os->opaque_rect.cy, delta);          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
106            out_uint16_le(s, (g_mcs_userid + 1001));
107    
108          if (present & 16)          out_uint32_le(s, g_rdp_shareid);
109                  prs_io_uint8(&conn->in, &os->opaque_rect.colour);          out_uint8(s, 0);        /* pad */
110            out_uint8(s, 1);        /* streamid */
111            out_uint16_le(s, (length - 14));
112            out_uint8(s, data_pdu_type);
113            out_uint8(s, 0);        /* compress_type */
114            out_uint16(s, 0);       /* compress_len */
115    
116          fprintf(stderr, "Opaque rectangle at %d, %d\n", os->opaque_rect.x, os->opaque_rect.y);          sec_send(s, g_encryption ? SEC_ENCRYPT : 0);
         ui_draw_rectangle(conn->wnd, os->opaque_rect.x, os->opaque_rect.y,  
                                 os->opaque_rect.cx, os->opaque_rect.cy);  
117  }  }
118    
119  void process_bmpcache(HCONN conn)  /* Output a string in Unicode */
120    void
121    rdp_out_unistr(STREAM s, char *string, int len)
122  {  {
123          RDP_BITMAP_HEADER rbh;          int i = 0, j = 0;
         HBITMAP *entry;  
         char *input, *bmpdata;  
   
         rdp_io_bitmap_header(&conn->in, &rbh);  
         fprintf(stderr, "BMPCACHE %d:%dx%d\n", rbh.cache_idx,  
                                 rbh.width, rbh.height);  
124    
125          input = conn->in.data + conn->in.offset;          len += 2;
         conn->in.offset += rbh.size;  
 //      dump_data(conn->in.data+conn->in.offset, conn->in.rdp_offset-conn->in.offset);  
126    
127          bmpdata = malloc(rbh.width * rbh.height);          while (i < len)
         if (!bitmap_decompress(bmpdata, rbh.width, rbh.height, input, rbh.size))  
128          {          {
129                  fprintf(stderr, "Decompression failed\n");                  s->p[i++] = string[j++];
130                  free(bmpdata);                  s->p[i++] = 0;
                 return;  
131          }          }
132    
133          if (rbh.cache_idx > NUM_ELEMENTS(conn->bmpcache))          s->p += len;
         {  
                 fprintf(stderr, "Attempted store past end of cache");  
                 return;  
         }  
   
         entry = &conn->bmpcache[rbh.cache_idx];  
         // if (*entry != NULL)  
         //      ui_destroy_bitmap(conn->wnd, *entry);  
   
         *entry = ui_create_bitmap(conn->wnd, rbh.width, rbh.height, bmpdata);  
         //      ui_paint_bitmap(conn->wnd, bmp, x, 0);  
         //      ui_destroy_bitmap(conn->wnd, bmp);  
134  }  }
135    
136  void process_orders(HCONN conn, RDP_ORDER_STATE *os)  /* Parse a logon info packet */
137    static void
138    rdp_send_logon_info(uint32 flags, char *domain, char *user,
139                        char *password, char *program, char *directory)
140  {  {
141          uint16 num_orders;          int len_domain = 2 * strlen(domain);
142          int processed = 0;          int len_user = 2 * strlen(user);
143          BOOL res = True;          int len_password = 2 * strlen(password);
144          BOOL delta;          int len_program = 2 * strlen(program);
145          //      unsigned char *p;          int len_directory = 2 * strlen(directory);
146            int len_ip = 2 * strlen("127.0.0.1");
147          lsb_io_uint16(&conn->in, &num_orders);          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
148            int packetlen = 0;
149            uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
150            STREAM s;
151            tzset();
152    
153          conn->in.offset += 2;          if (!g_use_rdp5 || 1 == g_server_rdp_version)
         //      p = &conn->in.data[conn->in.offset];  
   
         //      fprintf(stderr, "%02X %02X %02X %02X\n", p[0], p[1], p[2], p[3]);  
   
         while ((processed < num_orders) && res)  
154          {          {
155                  uint8 order_flags;                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
   
                 prs_io_uint8(&conn->in, &order_flags);  
                 fprintf(stderr, "Order flags: 0x%x\n", order_flags);  
156    
157                  if (order_flags == 0x51) /* ?? */                  s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
158                          return;                               + len_program + len_directory + 10);
159    
160                  if (!(order_flags & RDP_ORDER_STANDARD))                  out_uint32(s, 0);
161                          return;                  out_uint32_le(s, flags);
162                    out_uint16_le(s, len_domain);
163                  if (order_flags & RDP_ORDER_SECONDARY)                  out_uint16_le(s, len_user);
164                    out_uint16_le(s, len_password);
165                    out_uint16_le(s, len_program);
166                    out_uint16_le(s, len_directory);
167                    rdp_out_unistr(s, domain, len_domain);
168                    rdp_out_unistr(s, user, len_user);
169                    rdp_out_unistr(s, password, len_password);
170                    rdp_out_unistr(s, program, len_program);
171                    rdp_out_unistr(s, directory, len_directory);
172            }
173            else
174            {
175                    flags |= RDP_LOGON_BLOB;
176                    DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
177                    packetlen = 4 + /* Unknown uint32 */
178                            4 +     /* flags */
179                            2 +     /* len_domain */
180                            2 +     /* len_user */
181                            (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
182                            (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
183                            2 +     /* len_program */
184                            2 +     /* len_directory */
185                            (0 < len_domain ? len_domain : 2) +     /* domain */
186                            len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
187                            (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
188                            (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
189                            2 +     /* Client ip length */
190                            len_ip +        /* Client ip */
191                            2 +     /* DLL string length */
192                            len_dll +       /* DLL string */
193                            2 +     /* Unknown */
194                            2 +     /* Unknown */
195                            64 +    /* Time zone #0 */
196                            2 +     /* Unknown */
197                            64 +    /* Time zone #1 */
198                            32;     /* Unknown */
199    
200                    s = sec_init(sec_flags, packetlen);
201                    DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
202    
203                    out_uint32(s, 0);       /* Unknown */
204                    out_uint32_le(s, flags);
205                    out_uint16_le(s, len_domain);
206                    out_uint16_le(s, len_user);
207                    if (flags & RDP_LOGON_AUTO)
208                  {                  {
209                          RDP_SECONDARY_ORDER rso;                          out_uint16_le(s, len_password);
210    
                         rdp_io_secondary_order(&conn->in, &rso);  
                         switch (rso.type)  
                         {  
                         case RDP_ORDER_BMPCACHE:  
                                 process_bmpcache(conn);  
                                 break;  
                         default:  
                                 fprintf(stderr, "Unknown secondary order %d\n",  
                                         rso.type);  
                                 return;  
                         }  
211                  }                  }
212                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
213                    {
214                            out_uint16_le(s, 0);
215                    }
216                    out_uint16_le(s, len_program);
217                    out_uint16_le(s, len_directory);
218                    if (0 < len_domain)
219                            rdp_out_unistr(s, domain, len_domain);
220                  else                  else
221                            out_uint16_le(s, 0);
222                    rdp_out_unistr(s, user, len_user);
223                    if (flags & RDP_LOGON_AUTO)
224                  {                  {
225                          if (order_flags & RDP_ORDER_CHANGE)                          rdp_out_unistr(s, password, len_password);
                                 prs_io_uint8(&conn->in, &os->order_type);  
   
                         delta = order_flags & RDP_ORDER_DELTA;  
   
                         switch (os->order_type)  
                         {  
                         case RDP_ORDER_OPAQUE_RECT:  
                                 process_opaque_rect(conn, os, delta);  
                                 break;  
   
                         case RDP_ORDER_MEMBLT:  
                                 process_memblt(conn, os, delta);  
                                 break;  
   
                         default:  
                                 fprintf(stderr, "Unknown order %d\n", os->order_type);  
                                 return;  
                         }  
226                  }                  }
227                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
228                    {
229                            out_uint16_le(s, 0);
230                    }
231                    if (0 < len_program)
232                    {
233                            rdp_out_unistr(s, program, len_program);
234    
235                  processed++;                  }
236          }                  else
237  }                  {
238                            out_uint16_le(s, 0);
239  void process_palette(HCONN conn)                  }
240  {                  if (0 < len_directory)
241          HCOLORMAP map;                  {
242          COLORMAP colors;                          rdp_out_unistr(s, directory, len_directory);
243                    }
244          rdp_io_colormap(&conn->in, &colors);                  else
245          map = ui_create_colormap(conn->wnd, &colors);                  {
246          ui_set_colormap(conn->wnd, map);                          out_uint16_le(s, 0);
247          // ui_destroy_colormap(map);                  }
248  }                  out_uint16_le(s, 2);
249                    out_uint16_le(s, len_ip + 2);   /* Length of client ip */
250                    rdp_out_unistr(s, "127.0.0.1", len_ip);
251                    out_uint16_le(s, len_dll + 2);
252                    rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
253                    out_uint16_le(s, timezone/60);
254                    out_uint16_le(s, 0x0000);
255                    rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
256                    out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
257    
 void process_update(HCONN conn, RDP_ORDER_STATE *os)  
 {  
         RDP_UPDATE_PDU update;  
258    
259          rdp_io_update_pdu(&conn->in, &update);                  out_uint32_le(s, 0x0a0000);
260          switch (update.update_type)                  out_uint32_le(s, 0x050000);
261          {                  out_uint32_le(s, 3);
262                  case RDP_UPDATE_ORDERS:                  out_uint32_le(s, 0);
263                          process_orders(conn, os);                  out_uint32_le(s, 0);
                         break;  
                 case RDP_UPDATE_PALETTE:  
                         process_palette(conn);  
                         break;  
                 case RDP_UPDATE_SYNCHRONIZE:  
                         break;  
                 default:  
                         fprintf(stderr, "Unknown update 0x%x\n",  
                                 update.update_type);  
         }  
264    
265  }                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid"));
266                    out_uint8s(s, 62 - 2 * strlen("GTB, sommartid"));
267    
268  void process_pointer(HCONN conn)                  out_uint32_le(s, 0x30000);
269  {                  out_uint32_le(s, 0x050000);
270          RDP_POINTER ptr;                  out_uint32_le(s, 2);
271                    out_uint32(s, 0);
272                    out_uint32_le(s, 0xffffffc4);
273                    out_uint32_le(s, 0xfffffffe);
274                    out_uint32_le(s, 0x0f);
275                    out_uint32(s, 0);
276    
         rdp_io_pointer(&conn->in, &ptr);  
277    
         switch (ptr.message)  
         {  
                 case RDP_POINTER_MOVE:  
                         ui_move_pointer(conn->wnd, ptr.x, ptr.y);  
                         break;  
                 default:  
                         fprintf(stderr, "Unknown pointer message 0x%x\n",  
                                 ptr.message);  
278          }          }
279            s_mark_end(s);
280            sec_send(s, sec_flags);
281  }  }
282    
283  /* Work this out later. This is useless anyway when encryption is off. */  /* Send a control PDU */
284  uint8 precanned_key_packet[] = {  static void
285     0x48,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x00,0x00,0x00,0x00,  rdp_send_control(uint16 action)
    0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x6c,0x86,  
    0xf7,0x99,0xef,0x60,0xc4,0x49,0x52,0xd0,0xd8,0xea,0xb5,0x4f,0x58,0x19,  
    0x52,0x2a,0x93,0x83,0x57,0x4f,0x4e,0x04,0xde,0x96,0x51,0xab,0x13,0x20,  
    0xd8,0xe5,0x00,0x00,0x00,0x00,0x00,0x00  
 };  
   
 /* Create an RC4 key and transfer it to the server */  
 void rdp_establish_key(HCONN conn)  
286  {  {
287          mcs_init_data(conn);          STREAM s;
         memcpy(conn->out.data + conn->out.offset, precanned_key_packet,  
                sizeof(precanned_key_packet));  
         conn->out.offset += sizeof(precanned_key_packet);  
         MARK_END(conn->out);  
         mcs_send_data(conn, MCS_GLOBAL_CHANNEL, True);  
 }  
   
 /* Horrible horrible certificate stuff. Work out later. */  
 uint8 precanned_cert_packet[] = {  
 0x80,0x00,0x00,0x00,0x12,0x02,0xb4,0x04,0x01,0x00,0x00,  
 0x00,0x00,0x00,0x01,0x02,0x9d,0xa3,0x7a,0x93,0x34,0x7b,0x28,0x37,0x24,0xa0,0x1f,  
 0x61,0x26,0xfd,0x96,0x3a,0x92,0x83,0xf3,0xe9,0x6a,0x2e,0x81,0x7c,0x2c,0xe4,0x72,//  
 0x01,0x18,0xe9,0xa1,0x0f,0x00,0x00,0x48,0x00,0x84,0x23,0x90,0xe6,0xd3,0xf8,0x20,  
 0xdb,0xa8,0x1b,0xb2,0xd0,0x78,0x2c,0x35,0xde,0xe3,0x0e,0x63,0x40,0xca,0xac,0x71,  
 0xc9,0x17,0x49,0x05,0x25,0xeb,0x9b,0xd0,0xa6,0x5c,0x90,0x3e,0x9d,0x4b,0x27,0x01,  
 0x79,0x1c,0x22,0xfb,0x3c,0x2c,0xb9,0x9f,0xf5,0x21,0xf3,0xee,0xd5,0x4d,0x47,0x1c,  
 0x85,0xbe,0x83,0x93,0xe8,0xed,0x8c,0x5c,0x82,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  
 0x00,0x01,0x00,0x10,0x04,0x30,0x82,0x04,0x0c,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,  
 0x0d,0x01,0x07,0x02,0xa0,0x82,0x03,0xfd,0x30,0x82,0x03,0xf9,0x02,0x01,0x01,0x31,  
 0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x82,  
 0x03,0xe1,0x30,0x82,0x01,0x77,0x30,0x82,0x01,0x25,0xa0,0x03,0x02,0x01,0x02,0x02,  
 0x08,0x01,0xbf,0x06,0x84,0x9d,0xdb,0x2d,0xe0,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,  
 0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x30,0x38,0x31,0x36,0x30,0x11,0x06,0x03,  
 0x55,0x04,0x03,0x1e,0x0a,0x00,0x4e,0x00,0x54,0x00,0x54,0x00,0x53,0x00,0x45,0x30,  
 0x21,0x06,0x03,0x55,0x04,0x07,0x1e,0x1a,0x00,0x4d,0x00,0x69,0x00,0x63,0x00,0x72,  
 0x00,0x6f,0x00,0x73,0x00,0x6f,0x00,0x66,0x00,0x74,0x00,0x2e,0x00,0x63,0x00,0x6f,  
 0x00,0x6d,0x30,0x1e,0x17,0x0d,0x39,0x39,0x30,0x39,0x32,0x34,0x31,0x32,0x30,0x32,  
 0x30,0x34,0x5a,0x17,0x0d,0x34,0x39,0x30,0x39,0x32,0x34,0x31,0x32,0x30,0x32,0x30,  
 0x34,0x5a,0x30,0x38,0x31,0x36,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x1e,0x0a,0x00,  
 0x4e,0x00,0x54,0x00,0x54,0x00,0x53,0x00,0x45,0x30,0x21,0x06,0x03,0x55,0x04,0x07,  
 0x1e,0x1a,0x00,0x4d,0x00,0x69,0x00,0x63,0x00,0x72,0x00,0x6f,0x00,0x73,0x00,0x6f,  
 0x00,0x66,0x00,0x74,0x00,0x2e,0x00,0x63,0x00,0x6f,0x00,0x6d,0x30,0x5c,0x30,0x0d,  
 0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,  
 0x30,0x48,0x02,0x41,0x00,0x91,0xb2,0x16,0x1c,0xae,0x4f,0x7f,0x7c,0xaf,0x57,0x2b,  
 0x23,0x4c,0x0c,0x25,0x3c,0x4f,0x66,0x9d,0x25,0xc3,0x4f,0x29,0xee,0x8b,0xda,0x4e,  
 0x95,0xe7,0x3b,0xaa,0xc0,0xa7,0xba,0xaf,0x99,0x8c,0x47,0x24,0x8b,0x09,0x77,0xbc,  
 0x2c,0xf4,0xe7,0x1a,0x07,0x58,0x7b,0x11,0x37,0x2a,0xa8,0x90,0xc3,0x50,0x92,0x80,  
 0x15,0xc5,0xda,0x51,0x8b,0x02,0x03,0x01,0x00,0x01,0xa3,0x13,0x30,0x11,0x30,0x0f,  
 0x06,0x03,0x55,0x1d,0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x00,0x30,  
 0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x03,0x41,0x00,0x14,0x04,0x67,  
 0x28,0xc8,0xd3,0x1f,0x13,0x14,0x2e,0x2c,0x93,0x09,0x25,0xbb,0xbe,0x86,0x6a,0xd3,  
 0x47,0x6f,0x44,0x16,0x7b,0x94,0x8c,0xb2,0xa2,0xd5,0xf7,0x4f,0xb1,0x8f,0x7f,0xde,  
 0x0b,0x88,0x34,0x4a,0x1d,0xdc,0xa1,0xfd,0x26,0xbd,0x43,0xbb,0x38,0xf1,0x87,0x34,  
 0xbb,0xe9,0x3b,0xfa,0x7f,0x1e,0xff,0xe1,0x10,0x7e,0xee,0x6e,0xd8,0x30,0x82,0x02,  
 0x62,0x30,0x82,0x02,0x10,0xa0,0x03,0x02,0x01,0x02,0x02,0x05,0x01,0x00,0x00,0x00,  
 0x01,0x30,0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x30,0x38,0x31,0x36,  
 0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x1e,0x0a,0x00,0x4e,0x00,0x54,0x00,0x54,0x00,  
 0x53,0x00,0x45,0x30,0x21,0x06,0x03,0x55,0x04,0x07,0x1e,0x1a,0x00,0x4d,0x00,0x69,  
 0x00,0x63,0x00,0x72,0x00,0x6f,0x00,0x73,0x00,0x6f,0x00,0x66,0x00,0x74,0x00,0x2e,  
 0x00,0x63,0x00,0x6f,0x00,0x6d,0x30,0x1e,0x17,0x0d,0x39,0x39,0x30,0x39,0x32,0x34,  
 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x17,0x0d,0x34,0x39,0x30,0x39,0x32,0x34,0x30,  
 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x79,0x31,0x77,0x30,0x17,0x06,0x03,0x55,0x04,  
 0x03,0x1e,0x10,0x00,0x52,0x00,0x45,0x00,0x53,0x00,0x37,0x00,0x2d,0x00,0x4e,0x00,  
 0x45,0x00,0x57,0x30,0x17,0x06,0x03,0x55,0x04,0x07,0x1e,0x10,0x00,0x7a,0x00,0x32,  
 0x00,0x32,0x00,0x33,0x00,0x32,0x00,0x32,0x00,0x30,0x00,0x33,0x30,0x43,0x06,0x03,  
 0x55,0x04,0x05,0x1e,0x3c,0x00,0x31,0x00,0x42,0x00,0x63,0x00,0x4b,0x00,0x65,0x00,  
 0x57,0x00,0x50,0x00,0x6c,0x00,0x37,0x00,0x58,0x00,0x47,0x00,0x61,0x00,0x73,0x00,  
 0x38,0x00,0x4a,0x00,0x79,0x00,0x50,0x00,0x34,0x00,0x30,0x00,0x7a,0x00,0x49,0x00,  
 0x6d,0x00,0x6e,0x00,0x6f,0x00,0x51,0x00,0x5a,0x00,0x59,0x00,0x3d,0x00,0x0d,0x00,  
 0x0a,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,  
 0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,0x00,0x91,0xb2,0x16,0x1c,0xae,0x4f,  
 0x7f,0x7c,0xaf,0x57,0x2b,0x23,0x4c,0x0c,0x25,0x3c,0x4f,0x66,0x9d,0x25,0xc3,0x4f,  
 0x29,0xee,0x8b,0xda,0x4e,0x95,0xe7,0x3b,0xaa,0xc0,0xa7,0xba,0xaf,0x99,0x8c,0x47,  
 0x24,0x8b,0x09,0x77,0xbc,0x2c,0xf4,0xe7,0x1a,0x07,0x58,0x7b,0x11,0x37,0x2a,0xa8,  
 0x90,0xc3,0x50,0x92,0x80,0x15,0xc5,0xda,0x51,0x8b,0x02,0x03,0x01,0x00,0x01,0xa3,  
 0x81,0xc3,0x30,0x81,0xc0,0x30,0x14,0x06,0x09,0x2b,0x06,0x01,0x04,0x01,0x82,0x37,  
 0x12,0x04,0x01,0x01,0xff,0x04,0x04,0x01,0x00,0x01,0x00,0x30,0x3c,0x06,0x09,0x2b,  
 0x06,0x01,0x04,0x01,0x82,0x37,0x12,0x02,0x01,0x01,0xff,0x04,0x2c,0x4d,0x00,0x69,  
 0x00,0x63,0x00,0x72,0x00,0x6f,0x00,0x73,0x00,0x6f,0x00,0x66,0x00,0x74,0x00,0x20,  
 0x00,0x43,0x00,0x6f,0x00,0x72,0x00,0x70,0x00,0x6f,0x00,0x72,0x00,0x61,0x00,0x74,  
 0x00,0x69,0x00,0x6f,0x00,0x6e,0x00,0x00,0x00,0x30,0x4c,0x06,0x09,0x2b,0x06,0x01,  
 0x04,0x01,0x82,0x37,0x12,0x05,0x01,0x01,0xff,0x04,0x3c,0x00,0x10,0x00,0x00,0x01,  
 0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x18,0x00,0x18,0x00,0x30,  
 0x00,0x01,0x00,0x32,0x00,0x33,0x00,0x36,0x00,0x2d,0x00,0x34,0x00,0x2e,0x00,0x30,  
 0x00,0x30,0x00,0x2d,0x00,0x45,0x00,0x58,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,  
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x1c,0x06,0x03,0x55,0x1d,0x23,0x01,0x01,  
 0xff,0x04,0x12,0x30,0x10,0xa1,0x07,0x81,0x05,0x4e,0x54,0x54,0x53,0x45,0x82,0x05,  
 0x01,0x00,0x00,0x00,0x01,0x30,0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,  
 0x03,0x41,0x00,0x7b,0x1d,0xfd,0x24,0xea,0xf2,0xe8,0x17,0xdd,0x88,0x7e,0xfd,0xee,  
 0x28,0x61,0x7a,0x02,0xc3,0x73,0xcf,0x32,0x0f,0x7c,0x66,0x87,0x31,0xa7,0xbe,0x1b,  
 0x31,0xe2,0x20,0xa5,0x76,0x91,0x68,0x97,0x53,0x9e,0x80,0xcd,0x2b,0xd0,0x8e,0x8b,  
 0x7f,0x89,0x1b,0x62,0xa8,0xf8,0xee,0x5e,0x56,0xbd,0x9c,0x6b,0x80,0x06,0x54,0xd3,  
 0xf0,0xbf,0xb2,0x31,0x00,0x01,0x00,0x14,0x00,0xc7,0x32,0xf2,0x5b,0x98,0x0e,0x04,  
 0x49,0xa0,0x27,0x7e,0xf5,0xf6,0x0f,0xda,0x08,0x1d,0xe9,0x79,0xd1,0x31,0xc6,0x50,  
 0x90,0x4a,0xd3,0x1f,0x1d,0xf0,0x65,0x0d,0xb6,0x1f,0xaf,0xc9,0x1d  
 };  
288    
289  /* Send license certificate and related data to the server */          s = rdp_init_data(8);
 void rdp_send_cert(HCONN conn)  
 {  
         mcs_init_data(conn);  
         prs_io_uint8s(&conn->out, precanned_cert_packet, sizeof(precanned_cert_packet));  
         MARK_END(conn->out);  
         mcs_send_data(conn, MCS_GLOBAL_CHANNEL, True);  
 }  
290    
291  /* Initialise RDP transport packet */          out_uint16_le(s, action);
292  void rdp_init(HCONN conn)          out_uint16(s, 0);       /* userid */
293  {          out_uint32(s, 0);       /* control id */
         mcs_init_data(conn);  
         PUSH_LAYER(conn->out, rdp_offset, 6);  
 }  
294    
295  /* Transmit RDP transport packet */          s_mark_end(s);
296  void rdp_send(HCONN conn, uint16 pdu_type)          rdp_send_data(s, RDP_DATA_PDU_CONTROL);
 {  
         RDP_HEADER hdr;  
         int length;  
   
         POP_LAYER(conn->out, rdp_offset);  
         length = conn->out.end - conn->out.offset;  
         rdp_make_header(&hdr, length, pdu_type, conn->mcs_userid);  
         rdp_io_header(&conn->out, &hdr);  
         mcs_send_data(conn, MCS_GLOBAL_CHANNEL, True);  
 }  
   
 /* Initialise RDP transport data packet */  
 void rdp_init_data(HCONN conn)  
 {  
         mcs_init_data(conn);  
         PUSH_LAYER(conn->out, rdp_offset, 18);  
297  }  }
298    
299  /* Transmit RDP transport data packet */  /* Send a synchronisation PDU */
300  void rdp_send_data(HCONN conn, uint16 data_pdu_type)  static void
301    rdp_send_synchronise(void)
302  {  {
303          RDP_HEADER hdr;          STREAM s;
         RDP_DATA_HEADER datahdr;  
         int length = conn->out.end - conn->out.offset;  
304    
305          POP_LAYER(conn->out, rdp_offset);          s = rdp_init_data(4);
         length = conn->out.end - conn->out.offset;  
         rdp_make_header(&hdr, length, RDP_PDU_DATA, conn->mcs_userid);  
         rdp_io_header(&conn->out, &hdr);  
         rdp_make_data_header(&datahdr, 0x103ea, length, data_pdu_type);  
         rdp_io_data_header(&conn->out, &datahdr);  
         mcs_send_data(conn, MCS_GLOBAL_CHANNEL, True);  
 }  
306    
307  void rdp_send_confirm_active(HCONN conn)          out_uint16_le(s, 1);    /* type */
308  {          out_uint16_le(s, 1002);
         RDP_ACTIVE_PDU active;  
309    
310          rdp_init(conn);          s_mark_end(s);
311          rdp_make_active_pdu(&active, 0x103ea, conn->mcs_userid);          rdp_send_data(s, RDP_DATA_PDU_SYNCHRONISE);
         rdp_io_active_pdu(&conn->out, &active, RDP_PDU_CONFIRM_ACTIVE);  
         MARK_END(conn->out);  
         rdp_send(conn, RDP_PDU_CONFIRM_ACTIVE);  
312  }  }
313    
314  void rdp_send_synchronize(HCONN conn)  /* Send a single input event */
315    void
316    rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
317  {  {
318          RDP_SYNCHRONIZE_PDU sync;          STREAM s;
   
         rdp_init_data(conn);  
         rdp_make_synchronize_pdu(&sync, 1002);  
         rdp_io_synchronize_pdu(&conn->out, &sync);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_SYNCHRONIZE);  
 }  
   
 void rdp_send_control(HCONN conn, uint16 action)  
 {  
         RDP_CONTROL_PDU control;  
   
         rdp_init_data(conn);  
         rdp_make_control_pdu(&control, action);  
         rdp_io_control_pdu(&conn->out, &control);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_CONTROL);  
 }  
319    
320  void rdp_send_fonts(HCONN conn, uint16 seqno)          s = rdp_init_data(16);
 {  
         RDP_FONT_PDU fonts;  
321    
322          rdp_init_data(conn);          out_uint16_le(s, 1);    /* number of events */
323          rdp_make_font_pdu(&fonts, seqno);          out_uint16(s, 0);       /* pad */
         rdp_io_font_pdu(&conn->out, &fonts);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_FONT2);  
 }  
324    
325  void rdp_send_input(HCONN conn)          out_uint32_le(s, time);
326  {          out_uint16_le(s, message_type);
327          RDP_INPUT_PDU input;          out_uint16_le(s, device_flags);
328            out_uint16_le(s, param1);
329            out_uint16_le(s, param2);
330    
331          rdp_init_data(conn);          s_mark_end(s);
332          rdp_make_input_pdu(&input);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
         rdp_io_input_pdu(&conn->out, &input);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_INPUT);  
333  }  }
334    
335  BOOL rdp_recv_pdu(HCONN conn, uint8 *type)  /* Send an (empty) font information PDU */
336    static void
337    rdp_send_fonts(uint16 seq)
338  {  {
339          RDP_HEADER hdr;          STREAM s;
340    
341          conn->in.offset = conn->in.rdp_offset;          s = rdp_init_data(8);
342    
343          if (conn->in.offset >= conn->in.end)          out_uint16(s, 0);       /* number of fonts */
344          {          out_uint16_le(s, 0x3e); /* unknown */
345                  if (!mcs_recv(conn, False))          out_uint16_le(s, seq);  /* unknown */
346                          return False;          out_uint16_le(s, 0x32); /* entry size */
         }  
   
         if (!rdp_io_header(&conn->in, &hdr))  
                 return False;  
   
         conn->in.rdp_offset += hdr.length;  
         *type = hdr.pdu_type & 0xf;  
   
 #if DEBUG  
         fprintf(stderr, "RDP packet (type %x):\n", *type);  
         dump_data(conn->in.data+conn->in.offset, conn->in.rdp_offset-conn->in.offset);  
 #endif  
347    
348          return True;          s_mark_end(s);
349            rdp_send_data(s, RDP_DATA_PDU_FONT2);
350  }  }
351    
352  /* Disconnect from the RDP layer */  /* Output general capability set */
353  void rdp_disconnect(HCONN conn)  static void
354    rdp_out_general_caps(STREAM s)
355  {  {
356          mcs_disconnect(conn);          out_uint16_le(s, RDP_CAPSET_GENERAL);
357  }          out_uint16_le(s, RDP_CAPLEN_GENERAL);
358    
359  void rdp_make_header(RDP_HEADER *hdr, uint16 length, uint16 pdu_type,          out_uint16_le(s, 1);    /* OS major type */
360                       uint16 userid)          out_uint16_le(s, 3);    /* OS minor type */
361  {          out_uint16_le(s, 0x200);        /* Protocol version */
362          hdr->length = length;          out_uint16(s, 0);       /* Pad */
363          hdr->pdu_type = pdu_type | 0x10; /* Version 1 */          out_uint16(s, 0);       /* Compression types */
364          hdr->userid = userid + 1001;          out_uint16_le(s, g_use_rdp5 ? 0x40d : 0);
365            /* Pad, according to T.128. 0x40d seems to
366               trigger
367               the server to start sending RDP5 packets.
368               However, the value is 0x1d04 with W2KTSK and
369               NT4MS. Hmm.. Anyway, thankyou, Microsoft,
370               for sending such information in a padding
371               field.. */
372            out_uint16(s, 0);       /* Update capability */
373            out_uint16(s, 0);       /* Remote unshare capability */
374            out_uint16(s, 0);       /* Compression level */
375            out_uint16(s, 0);       /* Pad */
376  }  }
377    
378  void rdp_make_data_header(RDP_DATA_HEADER *hdr, uint32 shareid,  /* Output bitmap capability set */
379                            uint16 length, uint16 data_pdu_type)  static void
380    rdp_out_bitmap_caps(STREAM s)
381  {  {
382          hdr->shareid = shareid;          out_uint16_le(s, RDP_CAPSET_BITMAP);
383          hdr->pad = 0;          out_uint16_le(s, RDP_CAPLEN_BITMAP);
         hdr->streamid = 1;  
         hdr->length = length - 14;  
         hdr->data_pdu_type = data_pdu_type;  
         hdr->compress_type = 0;  
         hdr->compress_len = 0;  
 }  
384    
385  void rdp_make_general_caps(RDP_GENERAL_CAPS *caps)          out_uint16_le(s, 8);    /* Preferred BPP */
386  {          out_uint16_le(s, 1);    /* Receive 1 BPP */
387          caps->os_major_type = 1;          out_uint16_le(s, 1);    /* Receive 4 BPP */
388          caps->os_minor_type = 3;          out_uint16_le(s, 1);    /* Receive 8 BPP */
389          caps->ver_protocol = 0x200;          out_uint16_le(s, 800);  /* Desktop width */
390            out_uint16_le(s, 600);  /* Desktop height */
391            out_uint16(s, 0);       /* Pad */
392            out_uint16(s, 0);       /* Allow resize */
393            out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
394            out_uint16(s, 0);       /* Unknown */
395            out_uint16_le(s, 1);    /* Unknown */
396            out_uint16(s, 0);       /* Pad */
397  }  }
398    
399  void rdp_make_bitmap_caps(RDP_BITMAP_CAPS *caps)  /* Output order capability set */
400    static void
401    rdp_out_order_caps(STREAM s)
402  {  {
403          caps->preferred_bpp = 8;          uint8 order_caps[32];
         caps->receive1bpp = 1;  
         caps->receive4bpp = 1;  
         caps->receive8bpp = 1;  
         caps->width = 640;  
         caps->height = 480;  
         caps->compression = 1;  
         caps->unknown2 = 1;  
 }  
404    
 void rdp_make_order_caps(RDP_ORDER_CAPS *caps)  
 {  
         caps->xgranularity = 1;  
         caps->ygranularity = 20;  
         caps->max_order_level = 1;  
         caps->num_fonts = 0x147;  
         caps->cap_flags = 0x2A;  
405    
406  //      caps->cap_flags = ORDER_CAP_NEGOTIATE | ORDER_CAP_NOSUPPORT;          memset(order_caps, 0, 32);
407            order_caps[0] = 1;      /* dest blt */
408            order_caps[1] = 1;      /* pat blt */
409            order_caps[2] = 1;      /* screen blt */
410            order_caps[3] = 1;      /* required for memblt? */
411            order_caps[8] = 1;      /* line */
412            order_caps[9] = 1;      /* line */
413            order_caps[10] = 1;     /* rect */
414            order_caps[11] = (g_desktop_save == False ? 0 : 1);     /* desksave */
415            order_caps[13] = 1;     /* memblt */
416            order_caps[14] = 1;     /* triblt */
417            order_caps[22] = 1;     /* polyline */
418            order_caps[27] = 1;     /* text2 */
419            out_uint16_le(s, RDP_CAPSET_ORDER);
420            out_uint16_le(s, RDP_CAPLEN_ORDER);
421    
422          caps->support[0] = caps->support[1] = caps->support[2]          out_uint8s(s, 20);      /* Terminal desc, pad */
423                  = caps->support[3] = caps->support[4] = caps->support[5]          out_uint16_le(s, 1);    /* Cache X granularity */
424                  = caps->support[6] = caps->support[8] = caps->support[11]          out_uint16_le(s, 20);   /* Cache Y granularity */
425                  = caps->support[12] = caps->support[22] = caps->support[28]          out_uint16(s, 0);       /* Pad */
426                  = caps->support[29] = caps->support[30] = 1;          out_uint16_le(s, 1);    /* Max order level */
427          caps->text_cap_flags = 0x6A1;          out_uint16_le(s, 0x147);        /* Number of fonts */
428          caps->desk_save_size = 0x38400;          out_uint16_le(s, 0x2a); /* Capability flags */
429          caps->unknown2 = 0x4E4;          out_uint8p(s, order_caps, 32);  /* Orders supported */
430            out_uint16_le(s, 0x6a1);        /* Text capability flags */
431            out_uint8s(s, 6);       /* Pad */
432            out_uint32_le(s, g_desktop_save == False ? 0 : 0x38400);        /* Desktop cache size */
433            out_uint32(s, 0);       /* Unknown */
434            out_uint32_le(s, 0x4e4);        /* Unknown */
435  }  }
436    
437  void rdp_make_bmpcache_caps(RDP_BMPCACHE_CAPS *caps)  /* Output bitmap cache capability set */
438    static void
439    rdp_out_bmpcache_caps(STREAM s)
440  {  {
441          caps->caches[0].entries = 0x258;          int Bpp;
442          caps->caches[0].max_cell_size = 0x100;          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
443          caps->caches[1].entries = 0x12c;          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
         caps->caches[1].max_cell_size = 0x400;  
         caps->caches[2].entries = 0x106;  
         caps->caches[2].max_cell_size = 0x1000;  
 }  
444    
445  void rdp_make_control_caps(RDP_CONTROL_CAPS *caps)          Bpp = (g_server_bpp + 7) / 8;
446  {          out_uint8s(s, 24);      /* unused */
447          caps->control_interest = 2;          out_uint16_le(s, 0x258);        /* entries */
448          caps->detach_interest = 2;          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
449            out_uint16_le(s, 0x12c);        /* entries */
450            out_uint16_le(s, 0x400 * Bpp);  /* max cell size */
451            out_uint16_le(s, 0x106);        /* entries */
452            out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
453  }  }
454    
455  void rdp_make_activate_caps(RDP_ACTIVATE_CAPS *caps)  /* Output control capability set */
456    static void
457    rdp_out_control_caps(STREAM s)
458  {  {
459  }          out_uint16_le(s, RDP_CAPSET_CONTROL);
460            out_uint16_le(s, RDP_CAPLEN_CONTROL);
461    
462  void rdp_make_pointer_caps(RDP_POINTER_CAPS *caps)          out_uint16(s, 0);       /* Control capabilities */
463  {          out_uint16(s, 0);       /* Remote detach */
464          caps->colour_pointer = 0;          out_uint16_le(s, 2);    /* Control interest */
465          caps->cache_size = 20;          out_uint16_le(s, 2);    /* Detach interest */
466  }  }
467    
468  void rdp_make_share_caps(RDP_SHARE_CAPS *caps, uint16 userid)  /* Output activation capability set */
469    static void
470    rdp_out_activate_caps(STREAM s)
471  {  {
472  }          out_uint16_le(s, RDP_CAPSET_ACTIVATE);
473            out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
474    
475  void rdp_make_colcache_caps(RDP_COLCACHE_CAPS *caps)          out_uint16(s, 0);       /* Help key */
476  {          out_uint16(s, 0);       /* Help index key */
477          caps->cache_size = 6;          out_uint16(s, 0);       /* Extended help key */
478            out_uint16(s, 0);       /* Window activate */
479  }  }
480    
481  void rdp_make_active_pdu(RDP_ACTIVE_PDU *pdu, uint32 shareid, uint16 userid)  /* Output pointer capability set */
482    static void
483    rdp_out_pointer_caps(STREAM s)
484  {  {
485          memset(pdu, 0, sizeof(*pdu));          out_uint16_le(s, RDP_CAPSET_POINTER);
486          pdu->shareid = shareid;          out_uint16_le(s, RDP_CAPLEN_POINTER);
         pdu->userid  = 1002;  
         pdu->source_len = sizeof(RDP_SOURCE);  
         memcpy(pdu->source, RDP_SOURCE, sizeof(RDP_SOURCE));  
487    
488          pdu->caps_len = RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER          out_uint16(s, 0);       /* Colour pointer */
489                  + RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE + RDP_CAPLEN_ACTIVATE          out_uint16_le(s, 20);   /* Cache size */
                 + RDP_CAPLEN_CONTROL + RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE  
                 + RDP_CAPLEN_UNKNOWN;  
         pdu->num_caps = 0xD;  
   
         rdp_make_general_caps (&pdu->general_caps );  
         rdp_make_bitmap_caps  (&pdu->bitmap_caps  );  
         rdp_make_order_caps   (&pdu->order_caps   );  
         rdp_make_bmpcache_caps(&pdu->bmpcache_caps);  
         rdp_make_control_caps (&pdu->control_caps );  
         rdp_make_activate_caps(&pdu->activate_caps);  
         rdp_make_pointer_caps (&pdu->pointer_caps );  
         rdp_make_share_caps   (&pdu->share_caps, userid);  
         rdp_make_colcache_caps(&pdu->colcache_caps);  
490  }  }
491    
492  void rdp_make_control_pdu(RDP_CONTROL_PDU *pdu, uint16 action)  /* Output share capability set */
493    static void
494    rdp_out_share_caps(STREAM s)
495  {  {
496          pdu->action = action;          out_uint16_le(s, RDP_CAPSET_SHARE);
497          pdu->userid = 0;          out_uint16_le(s, RDP_CAPLEN_SHARE);
         pdu->controlid = 0;  
 }  
498    
499  void rdp_make_synchronize_pdu(RDP_SYNCHRONIZE_PDU *pdu, uint16 userid)          out_uint16(s, 0);       /* userid */
500  {          out_uint16(s, 0);       /* pad */
         pdu->type = 1;  
         pdu->userid = userid;  
501  }  }
502    
503  void rdp_make_font_pdu(RDP_FONT_PDU *pdu, uint16 seqno)  /* Output colour cache capability set */
504    static void
505    rdp_out_colcache_caps(STREAM s)
506  {  {
507          pdu->num_fonts = 0;          out_uint16_le(s, RDP_CAPSET_COLCACHE);
508          pdu->unknown1 = 0x3e;          out_uint16_le(s, RDP_CAPLEN_COLCACHE);
         pdu->unknown2 = seqno;  
         pdu->entry_size = RDP_FONT_INFO_SIZE;  
 }  
   
 void rdp_make_input_pdu(RDP_INPUT_PDU *pdu)  
 {  
         uint32 now = time(NULL);  
   
         pdu->num_events = 3;  
         pdu->pad = 0;  
   
         pdu->event[0].event_time = now;  
         pdu->event[0].message_type = RDP_INPUT_SYNCHRONIZE;  
         pdu->event[0].device_flags = 0;  
         pdu->event[0].mouse_x = 0;  
         pdu->event[0].mouse_y = 0;  
509    
510          pdu->event[1].event_time = now;          out_uint16_le(s, 6);    /* cache size */
511          pdu->event[1].message_type = RDP_INPUT_UNKNOWN;          out_uint16(s, 0);       /* pad */
         pdu->event[1].device_flags = 0x8000;  
         pdu->event[1].mouse_x = 15;  
         pdu->event[1].mouse_y = 0;  
   
         pdu->event[2].event_time = now;  
         pdu->event[2].message_type = RDP_INPUT_MOUSE;  
         pdu->event[2].device_flags = MOUSE_FLAG_MOVE;  
         pdu->event[2].mouse_x = 425;  
         pdu->event[2].mouse_y = 493;  
512  }  }
513    
514  BOOL rdp_io_header(STREAM s, RDP_HEADER *hdr)  static uint8 canned_caps[] = {
515  {          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
516          BOOL res = True;          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
517            0x00, 0x00, 0x00, 0x00, 0x00,
518          res = res ? lsb_io_uint16(s, &hdr->length  ) : False;          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
519          res = res ? lsb_io_uint16(s, &hdr->pdu_type) : False;          0x00, 0x00, 0x00, 0x00, 0x00,
520          res = res ? lsb_io_uint16(s, &hdr->userid  ) : False;          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
521            0x00, 0x00, 0x00, 0x00, 0x00,
522          return res;          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
523  }          0x00, 0x00, 0x00, 0x00, 0x00,
524            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
525            0x0C, 0x00, 0x08, 0x00, 0x01,
526            0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
527            0x10, 0x00, 0x34, 0x00, 0xFE,
528            0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
529            0xFE, 0x00, 0x08, 0x00, 0xFE,
530            0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
531            0xFE, 0x00, 0x80, 0x00, 0xFE,
532            0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
533            0x02, 0x00, 0x00, 0x00
534    };
535    
536  BOOL rdp_io_data_header(STREAM s, RDP_DATA_HEADER *hdr)  /* Output unknown capability sets (number 13, 12, 14 and 16) */
537    static void
538    rdp_out_unknown_caps(STREAM s)
539    {
540            out_uint16_le(s, RDP_CAPSET_UNKNOWN);
541            out_uint16_le(s, 0x58);
542    
543            out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);
544    }
545    
546    #define RDP5_FLAG 0x0030
547    /* Send a confirm active PDU */
548    static void
549    rdp_send_confirm_active(void)
550    {
551            STREAM s;
552            uint32 sec_flags = g_encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
553            uint16 caplen =
554                    RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
555                    RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
556                    RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
557                    RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
558    
559            s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
560    
561            out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));
562            out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
563            out_uint16_le(s, (g_mcs_userid + 1001));
564    
565            out_uint32_le(s, g_rdp_shareid);
566            out_uint16_le(s, 0x3ea);        /* userid */
567            out_uint16_le(s, sizeof(RDP_SOURCE));
568            out_uint16_le(s, caplen);
569    
570            out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));
571            out_uint16_le(s, 0xd);  /* num_caps */
572            out_uint8s(s, 2);       /* pad */
573    
574            rdp_out_general_caps(s);
575            rdp_out_bitmap_caps(s);
576            rdp_out_order_caps(s);
577            rdp_out_bmpcache_caps(s);
578            rdp_out_colcache_caps(s);
579            rdp_out_activate_caps(s);
580            rdp_out_control_caps(s);
581            rdp_out_pointer_caps(s);
582            rdp_out_share_caps(s);
583            rdp_out_unknown_caps(s);
584    
585            s_mark_end(s);
586            sec_send(s, sec_flags);
587    }
588    
589    /* Respond to a demand active PDU */
590    static void
591    process_demand_active(STREAM s)
592  {  {
593          BOOL res = True;          uint8 type;
594    
595          res = res ? lsb_io_uint32(s, &hdr->shareid      ) : False;          in_uint32_le(s, g_rdp_shareid);
         res = res ? prs_io_uint8 (s, &hdr->pad          ) : False;  
         res = res ? prs_io_uint8 (s, &hdr->streamid     ) : False;  
         res = res ? lsb_io_uint16(s, &hdr->length       ) : False;  
         res = res ? prs_io_uint8 (s, &hdr->data_pdu_type) : False;  
         res = res ? prs_io_uint8 (s, &hdr->compress_type) : False;  
         res = res ? lsb_io_uint16(s, &hdr->compress_len ) : False;  
596    
597          return res;          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
 }  
598    
599  BOOL rdp_io_coord(STREAM s, uint16 *coord, BOOL delta)          rdp_send_confirm_active();
600            rdp_send_synchronise();
601            rdp_send_control(RDP_CTL_COOPERATE);
602            rdp_send_control(RDP_CTL_REQUEST_CONTROL);
603            rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
604            rdp_recv(&type);        /* RDP_CTL_COOPERATE */
605            rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
606            rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);
607            rdp_send_fonts(1);
608            rdp_send_fonts(2);
609            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
610            reset_order_state();
611    }
612    
613    /* Process a colour pointer PDU */
614    void
615    process_colour_pointer_pdu(STREAM s)
616    {
617            uint16 x, y, width, height, cache_idx, masklen, datalen;
618            uint8 *mask, *data;
619            HCURSOR cursor;
620    
621            in_uint16_le(s, cache_idx);
622            in_uint16_le(s, x);
623            in_uint16_le(s, y);
624            in_uint16_le(s, width);
625            in_uint16_le(s, height);
626            in_uint16_le(s, masklen);
627            in_uint16_le(s, datalen);
628            in_uint8p(s, data, datalen);
629            in_uint8p(s, mask, masklen);
630            cursor = ui_create_cursor(x, y, width, height, mask, data);
631            ui_set_cursor(cursor);
632            cache_put_cursor(cache_idx, cursor);
633    }
634    
635    /* Process a cached pointer PDU */
636    void
637    process_cached_pointer_pdu(STREAM s)
638    {
639            uint16 cache_idx;
640    
641            in_uint16_le(s, cache_idx);
642            ui_set_cursor(cache_get_cursor(cache_idx));
643    }
644    
645    /* Process a system pointer PDU */
646    void
647    process_system_pointer_pdu(STREAM s)
648  {  {
649          uint8 change;          uint16 system_pointer_type;
         BOOL res;  
650    
651          if (delta)          in_uint16(s, system_pointer_type);
652          {          switch (system_pointer_type)
                 res = prs_io_uint8(s, &change);  
                 *coord += change;  
         }  
         else  
653          {          {
654                  res = lsb_io_uint16(s, coord);                  case RDP_NULL_POINTER:
655          }                          ui_set_null_cursor();
656                            break;
657    
658          return res;                  default:
659                            unimpl("System pointer message 0x%x\n", system_pointer_type);
660            }
661  }  }
662    
663  BOOL rdp_io_colormap(STREAM s, COLORMAP *colors)  /* Process a pointer PDU */
664    static void
665    process_pointer_pdu(STREAM s)
666  {  {
667          int datasize;          uint16 message_type;
668            uint16 x, y;
         lsb_io_uint16(s, &colors->ncolors);  
         datasize = colors->ncolors * 3;  
669    
670          if (datasize > sizeof(colors->colors))          in_uint16_le(s, message_type);
671                  return False;          in_uint8s(s, 2);        /* pad */
   
         memcpy(colors->colors, s->data + s->offset, datasize);  
         s->offset += datasize;  
         return True;  
 }  
   
 BOOL rdp_io_general_caps(STREAM s, RDP_GENERAL_CAPS *caps)  
 {  
         uint16 length = RDP_CAPLEN_GENERAL;  
         uint16 pkt_length = length;  
         BOOL res;  
672    
673          res = lsb_io_uint16(s, &pkt_length);          switch (message_type)
         if (pkt_length != length)  
674          {          {
675                  fprintf(stderr, "Unrecognised capabilities size\n");                  case RDP_POINTER_MOVE:
676                  return False;                          in_uint16_le(s, x);
677          }                          in_uint16_le(s, y);
678                            if (s_check(s))
679                                    ui_move_pointer(x, y);
680                            break;
681    
682          res = res ? lsb_io_uint16(s, &caps->os_major_type ) : False;                  case RDP_POINTER_COLOR:
683          res = res ? lsb_io_uint16(s, &caps->os_minor_type ) : False;                          process_colour_pointer_pdu(s);
684          res = res ? lsb_io_uint16(s, &caps->ver_protocol  ) : False;                          break;
         res = res ? lsb_io_uint16(s, &caps->pad1          ) : False;  
         res = res ? lsb_io_uint16(s, &caps->compress_types) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad2          ) : False;  
         res = res ? lsb_io_uint16(s, &caps->cap_update    ) : False;  
         res = res ? lsb_io_uint16(s, &caps->remote_unshare) : False;  
         res = res ? lsb_io_uint16(s, &caps->compress_level) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad3          ) : False;  
   
         return res;  
 }  
   
 BOOL rdp_io_bitmap_caps(STREAM s, RDP_BITMAP_CAPS *caps)  
 {  
         uint16 length = RDP_CAPLEN_BITMAP;  
         uint16 pkt_length = length;  
         BOOL res;  
685    
686          res = lsb_io_uint16(s, &pkt_length);                  case RDP_POINTER_CACHED:
687          if (pkt_length != length)                          process_cached_pointer_pdu(s);
688          {                          break;
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
689    
690          res = res ? lsb_io_uint16(s, &caps->preferred_bpp) : False;                  case RDP_POINTER_SYSTEM:
691          res = res ? lsb_io_uint16(s, &caps->receive1bpp  ) : False;                          process_system_pointer_pdu(s);
692          res = res ? lsb_io_uint16(s, &caps->receive4bpp  ) : False;                          break;
         res = res ? lsb_io_uint16(s, &caps->receive8bpp  ) : False;  
         res = res ? lsb_io_uint16(s, &caps->width        ) : False;  
         res = res ? lsb_io_uint16(s, &caps->height       ) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad1         ) : False;  
         res = res ? lsb_io_uint16(s, &caps->allow_resize ) : False;  
         res = res ? lsb_io_uint16(s, &caps->compression  ) : False;  
         res = res ? lsb_io_uint16(s, &caps->unknown1     ) : False;  
         res = res ? lsb_io_uint16(s, &caps->unknown2     ) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad2         ) : False;  
   
         return res;  
 }  
   
 BOOL rdp_io_order_caps(STREAM s, RDP_ORDER_CAPS *caps)  
 {  
         uint16 length = RDP_CAPLEN_ORDER;  
         uint16 pkt_length = length;  
         BOOL res;  
693    
694          res = lsb_io_uint16(s, &pkt_length);                  default:
695          if (pkt_length != length)                          unimpl("Pointer message 0x%x\n", message_type);
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
696          }          }
   
         res = res ? prs_io_uint8s(s,  caps->terminal_desc, 16) : False;  
         res = res ? lsb_io_uint32(s, &caps->pad1             ) : False;  
         res = res ? lsb_io_uint16(s, &caps->xgranularity     ) : False;  
         res = res ? lsb_io_uint16(s, &caps->ygranularity     ) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad2             ) : False;  
         res = res ? lsb_io_uint16(s, &caps->max_order_level  ) : False;  
         res = res ? lsb_io_uint16(s, &caps->num_fonts        ) : False;  
         res = res ? lsb_io_uint16(s, &caps->cap_flags        ) : False;  
         res = res ? prs_io_uint8s(s,  caps->support      , 32) : False;  
         res = res ? lsb_io_uint16(s, &caps->text_cap_flags   ) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad3             ) : False;  
         res = res ? lsb_io_uint32(s, &caps->pad4             ) : False;  
         res = res ? lsb_io_uint32(s, &caps->desk_save_size   ) : False;  
         res = res ? lsb_io_uint32(s, &caps->unknown1         ) : False;  
         res = res ? lsb_io_uint32(s, &caps->unknown2         ) : False;  
   
         return res;  
 }  
   
 BOOL rdp_io_bmpcache_info(STREAM s, RDP_BMPCACHE_INFO *info)  
 {  
         if (!lsb_io_uint16(s, &info->entries      ))  
                 return False;  
   
         if (!lsb_io_uint16(s, &info->max_cell_size))  
                 return False;  
   
         return True;  
697  }  }
698    
699  BOOL rdp_io_bmpcache_caps(STREAM s, RDP_BMPCACHE_CAPS *caps)  /* Process bitmap updates */
700    void
701    process_bitmap_updates(STREAM s)
702  {  {
703          uint16 length = RDP_CAPLEN_BMPCACHE;          uint16 num_updates;
704          uint16 pkt_length = length;          uint16 left, top, right, bottom, width, height;
705          BOOL res;          uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
706            uint8 *data, *bmpdata;
707          int i;          int i;
708    
709          res = lsb_io_uint16(s, &pkt_length);          in_uint16_le(s, num_updates);
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
   
         for (i = 0; i < 6; i++)  
                 res = res ? lsb_io_uint32(s, &caps->unused[i]) : False;  
   
         for (i = 0; i < 3; i++)  
                 res = res ? rdp_io_bmpcache_info(s, &caps->caches[i]) : False;  
   
         return res;  
 }  
   
 BOOL rdp_io_control_caps(STREAM s, RDP_CONTROL_CAPS *caps)  
 {  
         uint16 length = RDP_CAPLEN_CONTROL;  
         uint16 pkt_length = length;  
         BOOL res;  
   
         res = lsb_io_uint16(s, &pkt_length);  
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
   
         res = res ? lsb_io_uint16(s, &caps->control_caps    ) : False;  
         res = res ? lsb_io_uint16(s, &caps->remote_detach   ) : False;  
         res = res ? lsb_io_uint16(s, &caps->control_interest) : False;  
         res = res ? lsb_io_uint16(s, &caps->detach_interest ) : False;  
710    
711          return res;          for (i = 0; i < num_updates; i++)
 }  
   
 BOOL rdp_io_activate_caps(STREAM s, RDP_ACTIVATE_CAPS *caps)  
 {  
         uint16 length = RDP_CAPLEN_ACTIVATE;  
         uint16 pkt_length = length;  
         BOOL res;  
   
         res = lsb_io_uint16(s, &pkt_length);  
         if (pkt_length != length)  
712          {          {
713                  fprintf(stderr, "Unrecognised capabilities size\n");                  in_uint16_le(s, left);
714                  return False;                  in_uint16_le(s, top);
715          }                  in_uint16_le(s, right);
716                    in_uint16_le(s, bottom);
717                    in_uint16_le(s, width);
718                    in_uint16_le(s, height);
719                    in_uint16_le(s, bpp);
720                    Bpp = (bpp + 7) / 8;
721                    in_uint16_le(s, compress);
722                    in_uint16_le(s, bufsize);
723    
724          res = res ? lsb_io_uint16(s, &caps->help_key         ) : False;                  cx = right - left + 1;
725          res = res ? lsb_io_uint16(s, &caps->help_index_key   ) : False;                  cy = bottom - top + 1;
         res = res ? lsb_io_uint16(s, &caps->help_extended_key) : False;  
         res = res ? lsb_io_uint16(s, &caps->window_activate  ) : False;  
726    
727          return res;                  DEBUG(("BITMAP_UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,Bpp=%d,cmp=%d)\n",
728  }                         left, top, right, bottom, width, height, Bpp, compress));
729    
730  BOOL rdp_io_pointer_caps(STREAM s, RDP_POINTER_CAPS *caps)                  /* Server may limit bpp - this is how we find out */
731  {                  if (g_server_bpp != bpp)
732          uint16 length = RDP_CAPLEN_POINTER;                  {
733          uint16 pkt_length = length;                          warning("Server limited colour depth to %d bits\n", bpp);
734          BOOL res;                          g_server_bpp = bpp;
735                    }
         res = lsb_io_uint16(s, &pkt_length);  
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
736    
737          res = res ? lsb_io_uint16(s, &caps->colour_pointer) : False;                  if (!compress)
738          res = res ? lsb_io_uint16(s, &caps->cache_size    ) : False;                  {
739                            int y;
740                            bmpdata = (uint8 *) xmalloc(width * height * Bpp);
741                            for (y = 0; y < height; y++)
742                            {
743                                    in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
744                                              width * Bpp);
745                            }
746                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
747                            xfree(bmpdata);
748                            continue;
749                    }
750    
         return res;  
 }  
751    
752  BOOL rdp_io_share_caps(STREAM s, RDP_SHARE_CAPS *caps)                  if (compress & 0x400)
753  {                  {
754          uint16 length = RDP_CAPLEN_SHARE;                          size = bufsize;
755          uint16 pkt_length = length;                  }
756          BOOL res;                  else
757                    {
758                            in_uint8s(s, 2);        /* pad */
759                            in_uint16_le(s, size);
760                            in_uint8s(s, 4);        /* line_size, final_size */
761                    }
762                    in_uint8p(s, data, size);
763                    bmpdata = (uint8 *) xmalloc(width * height * Bpp);
764                    if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
765                    {
766                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
767                    }
768                    else
769                    {
770                            DEBUG_RDP5(("Failed to decompress data\n"));
771                    }
772    
773          res = lsb_io_uint16(s, &pkt_length);                  xfree(bmpdata);
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
774          }          }
   
         res = res ? lsb_io_uint16(s, &caps->userid) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad   ) : False;  
   
         return res;  
775  }  }
776    
777  BOOL rdp_io_colcache_caps(STREAM s, RDP_COLCACHE_CAPS *caps)  /* Process a palette update */
778    void
779    process_palette(STREAM s)
780  {  {
781          uint16 length = RDP_CAPLEN_COLCACHE;          COLOURENTRY *entry;
782          uint16 pkt_length = length;          COLOURMAP map;
783          BOOL res;          HCOLOURMAP hmap;
784            int i;
         res = lsb_io_uint16(s, &pkt_length);  
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
   
         res = res ? lsb_io_uint16(s, &caps->cache_size) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad       ) : False;  
785    
786          return res;          in_uint8s(s, 2);        /* pad */
787  }          in_uint16_le(s, map.ncolours);
788            in_uint8s(s, 2);        /* pad */
789    
790  uint8 canned_caps[] = {          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
 0x01,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x04,  
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x08,0x00,0x01,  
 0x00,0x00,0x00,0x0E,0x00,0x08,0x00,0x01,0x00,0x00,0x00,0x10,0x00,0x34,0x00,0xFE,  
 0x00,0x04,0x00,0xFE,0x00,0x04,0x00,0xFE,0x00,0x08,0x00,0xFE,0x00,0x08,0x00,0xFE,  
 0x00,0x10,0x00,0xFE,0x00,0x20,0x00,0xFE,0x00,0x40,0x00,0xFE,0x00,0x80,0x00,0xFE,  
 0x00,0x00,0x01,0x40,0x00,0x00,0x08,0x00,0x01,0x00,0x01,0x02,0x00,0x00,0x00  
 };  
791    
792  BOOL rdp_io_unknown_caps(STREAM s, void *caps)          DEBUG(("PALETTE(c=%d)\n", map.ncolours));
 {  
         uint16 length = 0x58;  
         uint16 pkt_length = length;  
         BOOL res;  
793    
794          res = lsb_io_uint16(s, &pkt_length);          for (i = 0; i < map.ncolours; i++)
         if (pkt_length != length)  
795          {          {
796                  fprintf(stderr, "Unrecognised capabilities size\n");                  entry = &map.colours[i];
797                  return False;                  in_uint8(s, entry->red);
798                    in_uint8(s, entry->green);
799                    in_uint8(s, entry->blue);
800          }          }
801    
802          res = res ? prs_io_uint8s(s, canned_caps, RDP_CAPLEN_UNKNOWN-4) : False;          hmap = ui_create_colourmap(&map);
803            ui_set_colourmap(hmap);
804    
805          return res;          xfree(map.colours);
806  }  }
807    
808  BOOL rdp_io_active_pdu(STREAM s, RDP_ACTIVE_PDU *pdu, int pdutype)  /* Process an update PDU */
809    static void
810    process_update_pdu(STREAM s)
811  {  {
812          uint16 capset;          uint16 update_type, count;
         uint16 length;  
         BOOL res;  
         int i;  
813    
814          res = lsb_io_uint32(s, &pdu->shareid);          in_uint16_le(s, update_type);
   
         if (pdutype == RDP_PDU_CONFIRM_ACTIVE)  
                 res = res ? lsb_io_uint16(s, &pdu->userid    ) : False;  
   
         res = res ? lsb_io_uint16(s, &pdu->source_len) : False;  
         res = res ? lsb_io_uint16(s, &pdu->caps_len  ) : False;  
   
         if (pdu->source_len > 48)  
         {  
                 fprintf(stderr, "RDP source descriptor too long\n");  
                 return False;  
         }  
815    
816          res = res ? prs_io_uint8s(s,  pdu->source, pdu->source_len) : False;          switch (update_type)
         res = res ? lsb_io_uint16(s, &pdu->num_caps  ) : False;  
         res = res ? lsb_io_uint16(s, &pdu->pad       ) : False;  
   
         if (s->marshall)  
         {  
                 capset = RDP_CAPSET_GENERAL;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_general_caps(s, &pdu->general_caps) : False;  
   
                 capset = RDP_CAPSET_BITMAP;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_bitmap_caps (s, &pdu->bitmap_caps ) : False;  
   
                 capset = RDP_CAPSET_ORDER;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_order_caps  (s, &pdu->order_caps  ) : False;  
   
                 capset = RDP_CAPSET_BMPCACHE;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_bmpcache_caps(s, &pdu->bmpcache_caps) : False;  
   
                 capset = RDP_CAPSET_COLCACHE;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_colcache_caps(s, &pdu->colcache_caps) : False;  
   
                 capset = RDP_CAPSET_ACTIVATE;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_activate_caps(s, &pdu->activate_caps) : False;  
   
                 capset = RDP_CAPSET_CONTROL;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_control_caps(s, &pdu->control_caps) : False;  
   
                 capset = RDP_CAPSET_POINTER;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_pointer_caps(s, &pdu->pointer_caps) : False;  
   
                 capset = RDP_CAPSET_SHARE;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_share_caps  (s, &pdu->share_caps  ) : False;  
   
                 capset = RDP_CAPSET_UNKNOWN;  
                 res = res ? lsb_io_uint16(s, &capset) : False;  
                 res = res ? rdp_io_unknown_caps(s, NULL) : False;  
         }  
         else  
817          {          {
818                  for (i = 0; i < pdu->num_caps; i++)                  case RDP_UPDATE_ORDERS:
819                  {                          in_uint8s(s, 2);        /* pad */
820                          if (!res)                          in_uint16_le(s, count);
821                                  return False;                          in_uint8s(s, 2);        /* pad */
822                            process_orders(s, count);
823                            break;
824    
825                          if (!lsb_io_uint16(s, &capset))                  case RDP_UPDATE_BITMAP:
826                                  return False;                          process_bitmap_updates(s);
827                            break;
828    
829                          switch (capset)                  case RDP_UPDATE_PALETTE:
830                          {                          process_palette(s);
831                          case RDP_CAPSET_GENERAL:                          break;
                                 res = rdp_io_general_caps (s, &pdu->general_caps );  
                                 break;  
                         case RDP_CAPSET_BITMAP:  
                                 res = rdp_io_bitmap_caps  (s, &pdu->bitmap_caps  );  
                                 break;  
                         case RDP_CAPSET_ORDER:  
                                 res = rdp_io_order_caps   (s, &pdu->order_caps   );  
                                 break;  
                         case RDP_CAPSET_BMPCACHE:  
                                 res = rdp_io_bmpcache_caps(s, &pdu->bmpcache_caps);  
                                 break;  
                         case RDP_CAPSET_CONTROL:  
                                 res = rdp_io_control_caps (s, &pdu->control_caps );  
                                 break;  
                         case RDP_CAPSET_ACTIVATE:  
                                 res = rdp_io_activate_caps(s, &pdu->activate_caps);  
                                 break;  
                         case RDP_CAPSET_POINTER:  
                                 res = rdp_io_pointer_caps (s, &pdu->pointer_caps );  
                                 break;  
                         case RDP_CAPSET_SHARE:  
                                 res = rdp_io_share_caps   (s, &pdu->share_caps   );  
                                 break;  
                         case RDP_CAPSET_COLCACHE:  
                                 res = rdp_io_colcache_caps(s, &pdu->colcache_caps);  
                                 break;  
                         default:  
                                 fprintf(stderr, "Warning: Unrecognised capset %x\n",  
                                         capset);  
832    
833                                  if (!lsb_io_uint16(s, &length))                  case RDP_UPDATE_SYNCHRONIZE:
834                                          return False;                          break;
835    
836                                  s->offset += (length - 4);                  default:
837                          }                          unimpl("update %d\n", update_type);
                 }  
838          }          }
839    
         return res;  
 }  
   
 BOOL rdp_io_control_pdu(STREAM s, RDP_CONTROL_PDU *pdu)  
 {  
         BOOL res = True;  
   
         res = res ? lsb_io_uint16(s, &pdu->action   ) : False;  
         res = res ? lsb_io_uint16(s, &pdu->userid   ) : False;  
         res = res ? lsb_io_uint32(s, &pdu->controlid) : False;  
   
         return res;  
 }  
   
 BOOL rdp_io_synchronize_pdu(STREAM s, RDP_SYNCHRONIZE_PDU *pdu)  
 {  
         BOOL res = True;  
   
         res = res ? lsb_io_uint16(s, &pdu->type  ) : False;  
         res = res ? lsb_io_uint16(s, &pdu->userid) : False;  
   
         return res;  
840  }  }
841    
842  BOOL rdp_io_input_event(STREAM s, RDP_INPUT_EVENT *evt)  /* Process data PDU */
843    static void
844    process_data_pdu(STREAM s)
845  {  {
846          BOOL res = True;          uint8 data_pdu_type;
   
         res = res ? lsb_io_uint32(s, &evt->event_time)   : False;  
         res = res ? lsb_io_uint16(s, &evt->message_type) : False;  
847    
848          if (!res)          in_uint8s(s, 8);        /* shareid, pad, streamid, length */
849                  return False;          in_uint8(s, data_pdu_type);
850            in_uint8s(s, 3);        /* compress_type, compress_len */
851    
852          switch (evt->message_type)          switch (data_pdu_type)
853          {          {
854          case RDP_INPUT_CODEPOINT:                  case RDP_DATA_PDU_UPDATE:
855          case RDP_INPUT_VIRTKEY:                          process_update_pdu(s);
856                  res = res ? lsb_io_uint16(s, &evt->device_flags) : False;                          break;
                 res = res ? lsb_io_uint16(s, &evt->kbd_keycode ) : False;  
                 break;  
         case RDP_INPUT_SYNCHRONIZE:  
         case RDP_INPUT_UNKNOWN:  
         case RDP_INPUT_MOUSE:  
                 res = res ? lsb_io_uint16(s, &evt->device_flags) : False;  
                 res = res ? lsb_io_uint16(s, &evt->mouse_x     ) : False;  
                 res = res ? lsb_io_uint16(s, &evt->mouse_y     ) : False;  
                 break;  
         default:  
                 fprintf(stderr, "Unknown input type %d\n", evt->message_type);  
                 return False;  
         }  
857    
858          return res;                  case RDP_DATA_PDU_POINTER:
859  }                          process_pointer_pdu(s);
860                            break;
861    
862  BOOL rdp_io_input_pdu(STREAM s, RDP_INPUT_PDU *pdu)                  case RDP_DATA_PDU_BELL:
863  {                          ui_bell();
864          BOOL res = True;                          break;
         int i;  
865    
866          res = res ? lsb_io_uint16(s, &pdu->num_events) : False;                  case RDP_DATA_PDU_LOGON:
867          res = res ? lsb_io_uint16(s, &pdu->pad       ) : False;                          DEBUG(("Received Logon PDU\n"));
868                            /* User logged on */
869                            break;
870    
871          if (pdu->num_events > RDP_MAX_EVENTS)                  case RDP_DATA_PDU_DISCONNECT:
872          {                          /* Normally received when user logs out or disconnects from a
873                  fprintf(stderr, "Too many events in one PDU\n");                             console session on Windows XP and 2003 Server */
874                  return False;                          DEBUG(("Received disconnect PDU\n"));
875          }                          break;
876    
877          for (i = 0; i < pdu->num_events; i++)                  default:
878          {                          unimpl("data PDU %d\n", data_pdu_type);
                 res = res ? rdp_io_input_event(s, &pdu->event[i]) : False;  
879          }          }
   
         return res;  
 }  
   
 BOOL rdp_io_font_info(STREAM s, RDP_FONT_INFO *font)  
 {  
         BOOL res = True;  
   
         res = res ? prs_io_uint8s(s,  font->name, 32 ) : False;  
         res = res ? lsb_io_uint16(s, &font->flags    ) : False;  
         res = res ? lsb_io_uint16(s, &font->width    ) : False;  
         res = res ? lsb_io_uint16(s, &font->height   ) : False;  
         res = res ? lsb_io_uint16(s, &font->xaspect  ) : False;  
         res = res ? lsb_io_uint16(s, &font->yaspect  ) : False;  
         res = res ? lsb_io_uint32(s, &font->signature) : False;  
         res = res ? lsb_io_uint16(s, &font->codepage ) : False;  
         res = res ? lsb_io_uint16(s, &font->ascent   ) : False;  
   
         return res;  
880  }  }
881    
882  BOOL rdp_io_font_pdu(STREAM s, RDP_FONT_PDU *pdu)  /* Process incoming packets */
883    BOOL
884    rdp_main_loop(void)
885  {  {
886          BOOL res = True;          uint8 type;
887          int i;          STREAM s;
   
         res = res ? lsb_io_uint16(s, &pdu->num_fonts ) : False;  
         res = res ? lsb_io_uint16(s, &pdu->unknown1  ) : False;  
         res = res ? lsb_io_uint16(s, &pdu->unknown2  ) : False;  
         res = res ? lsb_io_uint16(s, &pdu->entry_size) : False;  
   
         if (pdu->num_fonts > RDP_MAX_FONTS)  
         {  
                 fprintf(stderr, "Too many fonts in one PDU\n");  
                 return False;  
         }  
888    
889          for (i = 0; i < pdu->num_fonts; i++)          while ((s = rdp_recv(&type)) != NULL)
890          {          {
891                  res = res ? rdp_io_font_info(s, &pdu->font[i]) : False;                  switch (type)
892          }                  {
893                            case RDP_PDU_DEMAND_ACTIVE:
894          return res;                                  process_demand_active(s);
895  }                                  break;
   
 BOOL rdp_io_update_pdu(STREAM s, RDP_UPDATE_PDU *pdu)  
 {  
         BOOL res = True;  
   
         res = res ? lsb_io_uint16(s, &pdu->update_type) : False;  
         res = res ? lsb_io_uint16(s, &pdu->pad        ) : False;  
896    
897          return res;                          case RDP_PDU_DEACTIVATE:
898  }                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
899                                    /* We thought we could detect a clean
900                                       shutdown of the session by this
901                                       packet, but it seems Windows 2003
902                                       is sending us one of these when we
903                                       reconnect to a disconnected session
904                                       return True; */
905                                    break;
906    
907  BOOL rdp_io_secondary_order(STREAM s, RDP_SECONDARY_ORDER *rso)                          case RDP_PDU_DATA:
908  {                                  process_data_pdu(s);
909          BOOL res = True;                                  break;
910    
911          res = res ? lsb_io_uint16(s, &rso->length) : False;                          case 0:
912          res = res ? lsb_io_uint16(s, &rso->flags ) : False;                                  break;
         res = res ? prs_io_uint8 (s, &rso->type  ) : False;  
913    
914          return res;                          default:
915                                    unimpl("PDU %d\n", type);
916                    }
917            }
918            return True;
919            /* We want to detect if we got a clean shutdown, but we
920               can't. Se above.  
921               return False;  */
922  }  }
923    
924  BOOL rdp_io_bitmap_header(STREAM s, RDP_BITMAP_HEADER *rdh)  /* Establish a connection up to the RDP layer */
925    BOOL
926    rdp_connect(char *server, uint32 flags, char *domain, char *password,
927                char *command, char *directory)
928  {  {
929          BOOL res = True;          if (!sec_connect(server, g_username))
930                    return False;
         res = res ? prs_io_uint8 (s, &rdh->cache_id  ) : False;  
         res = res ? prs_io_uint8 (s, &rdh->pad1      ) : False;  
         res = res ? prs_io_uint8 (s, &rdh->width     ) : False;  
         res = res ? prs_io_uint8 (s, &rdh->height    ) : False;  
         res = res ? prs_io_uint8 (s, &rdh->bpp       ) : False;  
         res = res ? lsb_io_uint16(s, &rdh->bufsize   ) : False;  
         res = res ? lsb_io_uint16(s, &rdh->cache_idx ) : False;  
         res = res ? lsb_io_uint16(s, &rdh->pad2      ) : False;  
         res = res ? lsb_io_uint16(s, &rdh->size      ) : False;  
         res = res ? lsb_io_uint16(s, &rdh->row_size  ) : False;  
         res = res ? lsb_io_uint16(s, &rdh->final_size) : False;  
931    
932          return res;          rdp_send_logon_info(flags, domain, g_username, password, command, directory);
933            return True;
934  }  }
935    
936  BOOL rdp_io_pointer(STREAM s, RDP_POINTER *ptr)  /* Disconnect from the RDP layer */
937    void
938    rdp_disconnect(void)
939  {  {
940          BOOL res = True;          sec_disconnect();
   
         res = res ? lsb_io_uint16(s, &ptr->message) : False;  
         res = res ? lsb_io_uint16(s, &ptr->pad    ) : False;  
         res = res ? lsb_io_uint16(s, &ptr->x      ) : False;  
         res = res ? lsb_io_uint16(s, &ptr->y      ) : False;  
   
         return res;  
941  }  }
Legend:
Removed from v.7  
changed lines
  Added in v.554
  ViewVC Help
Powered by ViewVC 1.1.26