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