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