/[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 436 by jsorg71, Mon Jul 28 18:13:30 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"
22    
23  /* Establish a connection up to the RDP layer */  extern uint16 g_mcs_userid;
24  HCONN rdp_connect(char *server)  extern char username[16];
25  {  extern BOOL bitmap_compression;
26          HCONN conn;  extern BOOL orders;
27          RDP_ACTIVE_PDU active;  extern BOOL encryption;
28          uint8 type;  extern BOOL desktop_save;
29    extern BOOL use_rdp5;
30          if ((conn = mcs_connect(server)) == NULL)  extern uint16 server_rdp_version;
31                  return NULL;  extern int server_bpp;
   
         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 */  
   
         if (!rdp_recv_pdu(conn, &type) || (type != RDP_PDU_DEMAND_ACTIVE))  
         {  
                 fprintf(stderr, "RDP error, expected Demand Active\n");  
                 mcs_disconnect(conn);  
                 return NULL;  
         }  
32    
33          rdp_io_active_pdu(&conn->in, &active, RDP_PDU_DEMAND_ACTIVE);  uint8 *next_packet;
34          rdp_send_confirm_active(conn);  uint32 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 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;  
46    
47          memset(&os, 0, sizeof(os));          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))
   
         while (rdp_recv_pdu(conn, &type))  
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;  
                 }  
   
                 rdp_io_data_header(&conn->in, &hdr);  
   
                 switch (hdr.data_pdu_type)  
                 {  
                         case RDP_DATA_PDU_UPDATE:  
                                 process_update(conn, &os);  
                                 break;  
52    
53                          case RDP_DATA_PDU_POINTER:                  next_packet = rdp_s->p;
                                 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 = 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);                  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", ++packetno, *type));
74            //      hexdump(next_packet, length);
75    #endif /*  */
76    
77          ui_paint_bitmap(conn->wnd, hbitmap, os->memblt.x, os->memblt.y);          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(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, 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, 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;  
122    
123          rdp_io_bitmap_header(&conn->in, &rbh);          len += 2;
         fprintf(stderr, "BMPCACHE %d:%dx%d\n", rbh.cache_idx,  
                                 rbh.width, rbh.height);  
124    
125          input = conn->in.data + conn->in.offset;          while (i < len)
         conn->in.offset += rbh.size;  
 //      dump_data(conn->in.data+conn->in.offset, conn->in.rdp_offset-conn->in.offset);  
   
         bmpdata = malloc(rbh.width * rbh.height);  
         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          conn->in.offset += 2;          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
148          //      p = &conn->in.data[conn->in.offset];          STREAM s;
   
         //      fprintf(stderr, "%02X %02X %02X %02X\n", p[0], p[1], p[2], p[3]);  
149    
150          while ((processed < num_orders) && res)          if (!use_rdp5 || 1 == server_rdp_version)
151          {          {
152                  uint8 order_flags;                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
153    
154                  prs_io_uint8(&conn->in, &order_flags);                  s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
155                  fprintf(stderr, "Order flags: 0x%x\n", order_flags);                               + len_program + len_directory + 10);
156    
157                  if (order_flags == 0x51) /* ?? */                  out_uint32(s, 0);
158                          return;                  out_uint32_le(s, flags);
159                    out_uint16_le(s, len_domain);
160                  if (!(order_flags & RDP_ORDER_STANDARD))                  out_uint16_le(s, len_user);
161                          return;                  out_uint16_le(s, len_password);
162                    out_uint16_le(s, len_program);
163                  if (order_flags & RDP_ORDER_SECONDARY)                  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);
223                                  prs_io_uint8(&conn->in, &os->order_type);                  }
224                    if (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO))
225                          delta = order_flags & RDP_ORDER_DELTA;                  {
226                            out_uint16_le(s, 0);
227                          switch (os->order_type)                  }
228                          {                  if (0 < len_program)
229                          case RDP_ORDER_OPAQUE_RECT:                  {
230                                  process_opaque_rect(conn, os, delta);                          rdp_out_unistr(s, program, len_program);
                                 break;  
   
                         case RDP_ORDER_MEMBLT:  
                                 process_memblt(conn, os, delta);  
                                 break;  
231    
                         default:  
                                 fprintf(stderr, "Unknown order %d\n", os->order_type);  
                                 return;  
                         }  
232                  }                  }
233                    else
234                    {
235                            out_uint16_le(s, 0);
236                    }
237                    if (0 < len_directory)
238                    {
239                            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                    out_uint16_le(s, 0xffc4);
251                    out_uint16_le(s, 0xffff);
252                    rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
253                    out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
254    
                 processed++;  
         }  
 }  
255    
256  void process_palette(HCONN conn)                  out_uint32_le(s, 0x0a0000);
257  {                  out_uint32_le(s, 0x050000);
258          HCOLORMAP map;                  out_uint32_le(s, 3);
259          COLORMAP colors;                  out_uint32_le(s, 0);
260                    out_uint32_le(s, 0);
261    
262          rdp_io_colormap(&conn->in, &colors);                  rdp_out_unistr(s, "GTB, sommartid", 2 * strlen("GTB, sommartid"));
263          map = ui_create_colormap(conn->wnd, &colors);                  out_uint8s(s, 62 - 2 * strlen("GTB, sommartid"));
         ui_set_colormap(conn->wnd, map);  
         // ui_destroy_colormap(map);  
 }  
264    
265  void process_update(HCONN conn, RDP_ORDER_STATE *os)                  out_uint32_le(s, 0x30000);
266  {                  out_uint32_le(s, 0x050000);
267          RDP_UPDATE_PDU update;                  out_uint32_le(s, 2);
268                    out_uint32(s, 0);
269                    out_uint32_le(s, 0xffffffc4);
270                    out_uint32_le(s, 0xfffffffe);
271                    out_uint32_le(s, 0x0f);
272                    out_uint32(s, 0);
273    
         rdp_io_update_pdu(&conn->in, &update);  
         switch (update.update_type)  
         {  
                 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);  
         }  
274    
275            }
276            s_mark_end(s);
277            sec_send(s, sec_flags);
278  }  }
279    
280  void process_pointer(HCONN conn)  /* Send a control PDU */
281    static void
282    rdp_send_control(uint16 action)
283  {  {
284          RDP_POINTER ptr;          STREAM s;
   
         rdp_io_pointer(&conn->in, &ptr);  
   
         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);  
         }  
 }  
285    
286  /* Work this out later. This is useless anyway when encryption is off. */          s = rdp_init_data(8);
 uint8 precanned_key_packet[] = {  
    0x48,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x00,0x00,0x00,0x00,  
    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  
 };  
287    
288  /* Create an RC4 key and transfer it to the server */          out_uint16_le(s, action);
289  void rdp_establish_key(HCONN conn)          out_uint16(s, 0);       /* userid */
290  {          out_uint32(s, 0);       /* control id */
         mcs_init_data(conn);  
         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_mark_end(s);
293  void rdp_send_cert(HCONN conn)          rdp_send_data(s, RDP_DATA_PDU_CONTROL);
 {  
         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);  
294  }  }
295    
296  /* Initialise RDP transport packet */  /* Send a synchronisation PDU */
297  void rdp_init(HCONN conn)  static void
298    rdp_send_synchronise(void)
299  {  {
300          mcs_init_data(conn);          STREAM s;
         PUSH_LAYER(conn->out, rdp_offset, 6);  
 }  
301    
302  /* Transmit RDP transport packet */          s = rdp_init_data(4);
 void rdp_send(HCONN conn, uint16 pdu_type)  
 {  
         RDP_HEADER hdr;  
         int length;  
303    
304          POP_LAYER(conn->out, rdp_offset);          out_uint16_le(s, 1);    /* type */
305          length = conn->out.end - conn->out.offset;          out_uint16_le(s, 1002);
         rdp_make_header(&hdr, length, pdu_type, conn->mcs_userid);  
         rdp_io_header(&conn->out, &hdr);  
         mcs_send_data(conn, MCS_GLOBAL_CHANNEL, True);  
 }  
306    
307  /* Initialise RDP transport data packet */          s_mark_end(s);
308  void rdp_init_data(HCONN conn)          rdp_send_data(s, RDP_DATA_PDU_SYNCHRONISE);
 {  
         mcs_init_data(conn);  
         PUSH_LAYER(conn->out, rdp_offset, 18);  
309  }  }
310    
311  /* Transmit RDP transport data packet */  /* Send a single input event */
312  void rdp_send_data(HCONN conn, uint16 data_pdu_type)  void
313    rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
314  {  {
315          RDP_HEADER hdr;          STREAM s;
         RDP_DATA_HEADER datahdr;  
         int length = conn->out.end - conn->out.offset;  
316    
317          POP_LAYER(conn->out, rdp_offset);          s = rdp_init_data(16);
         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);  
 }  
318    
319  void rdp_send_confirm_active(HCONN conn)          out_uint16_le(s, 1);    /* number of events */
320  {          out_uint16(s, 0);       /* pad */
321          RDP_ACTIVE_PDU active;  
322            out_uint32_le(s, time);
323            out_uint16_le(s, message_type);
324            out_uint16_le(s, device_flags);
325            out_uint16_le(s, param1);
326            out_uint16_le(s, param2);
327    
328          rdp_init(conn);          s_mark_end(s);
329          rdp_make_active_pdu(&active, 0x103ea, conn->mcs_userid);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
         rdp_io_active_pdu(&conn->out, &active, RDP_PDU_CONFIRM_ACTIVE);  
         MARK_END(conn->out);  
         rdp_send(conn, RDP_PDU_CONFIRM_ACTIVE);  
330  }  }
331    
332  void rdp_send_synchronize(HCONN conn)  /* Send an (empty) font information PDU */
333    static void
334    rdp_send_fonts(uint16 seq)
335  {  {
336          RDP_SYNCHRONIZE_PDU sync;          STREAM s;
337    
338          rdp_init_data(conn);          s = rdp_init_data(8);
         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);  
 }  
339    
340  void rdp_send_control(HCONN conn, uint16 action)          out_uint16(s, 0);       /* number of fonts */
341  {          out_uint16_le(s, 0x3e); /* unknown */
342          RDP_CONTROL_PDU control;          out_uint16_le(s, seq);  /* unknown */
343            out_uint16_le(s, 0x32); /* entry size */
344    
345          rdp_init_data(conn);          s_mark_end(s);
346          rdp_make_control_pdu(&control, action);          rdp_send_data(s, RDP_DATA_PDU_FONT2);
         rdp_io_control_pdu(&conn->out, &control);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_CONTROL);  
347  }  }
348    
349  void rdp_send_fonts(HCONN conn, uint16 seqno)  /* Output general capability set */
350    static void
351    rdp_out_general_caps(STREAM s)
352  {  {
353          RDP_FONT_PDU fonts;          out_uint16_le(s, RDP_CAPSET_GENERAL);
354            out_uint16_le(s, RDP_CAPLEN_GENERAL);
355    
356          rdp_init_data(conn);          out_uint16_le(s, 1);    /* OS major type */
357          rdp_make_font_pdu(&fonts, seqno);          out_uint16_le(s, 3);    /* OS minor type */
358          rdp_io_font_pdu(&conn->out, &fonts);          out_uint16_le(s, 0x200);        /* Protocol version */
359          MARK_END(conn->out);          out_uint16(s, 0);       /* Pad */
360          rdp_send_data(conn, RDP_DATA_PDU_FONT2);          out_uint16(s, 0);       /* Compression types */
361            out_uint16_le(s, use_rdp5 ? 0x40d : 0);
362            /* Pad, according to T.128. 0x40d seems to
363               trigger
364               the server to start sending RDP5 packets.
365               However, the value is 0x1d04 with W2KTSK and
366               NT4MS. Hmm.. Anyway, thankyou, Microsoft,
367               for sending such information in a padding
368               field.. */
369            out_uint16(s, 0);       /* Update capability */
370            out_uint16(s, 0);       /* Remote unshare capability */
371            out_uint16(s, 0);       /* Compression level */
372            out_uint16(s, 0);       /* Pad */
373  }  }
374    
375  void rdp_send_input(HCONN conn)  /* Output bitmap capability set */
376    static void
377    rdp_out_bitmap_caps(STREAM s)
378  {  {
379          RDP_INPUT_PDU input;          out_uint16_le(s, RDP_CAPSET_BITMAP);
380            out_uint16_le(s, RDP_CAPLEN_BITMAP);
381    
382          rdp_init_data(conn);          out_uint16_le(s, 8);    /* Preferred BPP */
383          rdp_make_input_pdu(&input);          out_uint16_le(s, 1);    /* Receive 1 BPP */
384          rdp_io_input_pdu(&conn->out, &input);          out_uint16_le(s, 1);    /* Receive 4 BPP */
385          MARK_END(conn->out);          out_uint16_le(s, 1);    /* Receive 8 BPP */
386          rdp_send_data(conn, RDP_DATA_PDU_INPUT);          out_uint16_le(s, 800);  /* Desktop width */
387            out_uint16_le(s, 600);  /* Desktop height */
388            out_uint16(s, 0);       /* Pad */
389            out_uint16(s, 0);       /* Allow resize */
390            out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */
391            out_uint16(s, 0);       /* Unknown */
392            out_uint16_le(s, 1);    /* Unknown */
393            out_uint16(s, 0);       /* Pad */
394  }  }
395    
396  BOOL rdp_recv_pdu(HCONN conn, uint8 *type)  /* Output order capability set */
397    static void
398    rdp_out_order_caps(STREAM s)
399  {  {
400          RDP_HEADER hdr;          uint8 order_caps[32];
401    
         conn->in.offset = conn->in.rdp_offset;  
402    
403          if (conn->in.offset >= conn->in.end)          memset(order_caps, 0, 32);
404          {          order_caps[0] = 1;      /* dest blt */
405                  if (!mcs_recv(conn, False))          order_caps[1] = 1;      /* pat blt */
406                          return False;          order_caps[2] = 1;      /* screen blt */
407          }          order_caps[3] = 1;      /* required for memblt? */
408            order_caps[8] = 1;      /* line */
409            order_caps[9] = 1;      /* line */
410            order_caps[10] = 1;     /* rect */
411            order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */
412            order_caps[13] = 1;     /* memblt */
413            order_caps[14] = 1;     /* triblt */
414            order_caps[22] = 1;     /* polyline */
415            order_caps[27] = 1;     /* text2 */
416            out_uint16_le(s, RDP_CAPSET_ORDER);
417            out_uint16_le(s, RDP_CAPLEN_ORDER);
418    
419          if (!rdp_io_header(&conn->in, &hdr))          out_uint8s(s, 20);      /* Terminal desc, pad */
420                  return False;          out_uint16_le(s, 1);    /* Cache X granularity */
421            out_uint16_le(s, 20);   /* Cache Y granularity */
422          conn->in.rdp_offset += hdr.length;          out_uint16(s, 0);       /* Pad */
423          *type = hdr.pdu_type & 0xf;          out_uint16_le(s, 1);    /* Max order level */
424            out_uint16_le(s, 0x147);        /* Number of fonts */
425  #if DEBUG          out_uint16_le(s, 0x2a); /* Capability flags */
426          fprintf(stderr, "RDP packet (type %x):\n", *type);          out_uint8p(s, order_caps, 32);  /* Orders supported */
427          dump_data(conn->in.data+conn->in.offset, conn->in.rdp_offset-conn->in.offset);          out_uint16_le(s, 0x6a1);        /* Text capability flags */
428  #endif          out_uint8s(s, 6);       /* Pad */
429            out_uint32_le(s, desktop_save == False ? 0 : 0x38400);  /* Desktop cache size */
430          return True;          out_uint32(s, 0);       /* Unknown */
431            out_uint32_le(s, 0x4e4);        /* Unknown */
432  }  }
433    
434  /* Disconnect from the RDP layer */  /* Output bitmap cache capability set */
435  void rdp_disconnect(HCONN conn)  static void
436    rdp_out_bmpcache_caps(STREAM s)
437  {  {
438          mcs_disconnect(conn);          int Bpp;
439  }          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
440            out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
441    
442  void rdp_make_header(RDP_HEADER *hdr, uint16 length, uint16 pdu_type,          Bpp = (server_bpp + 7) / 8;
443                       uint16 userid)          out_uint8s(s, 24);      /* unused */
444  {          out_uint16_le(s, 0x258);        /* entries */
445          hdr->length = length;          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
446          hdr->pdu_type = pdu_type | 0x10; /* Version 1 */          out_uint16_le(s, 0x12c);        /* entries */
447          hdr->userid = userid + 1001;          out_uint16_le(s, 0x400 * Bpp);  /* max cell size */
448            out_uint16_le(s, 0x106);        /* entries */
449            out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
450  }  }
451    
452  void rdp_make_data_header(RDP_DATA_HEADER *hdr, uint32 shareid,  /* Output control capability set */
453                            uint16 length, uint16 data_pdu_type)  static void
454    rdp_out_control_caps(STREAM s)
455  {  {
456          hdr->shareid = shareid;          out_uint16_le(s, RDP_CAPSET_CONTROL);
457          hdr->pad = 0;          out_uint16_le(s, RDP_CAPLEN_CONTROL);
         hdr->streamid = 1;  
         hdr->length = length - 14;  
         hdr->data_pdu_type = data_pdu_type;  
         hdr->compress_type = 0;  
         hdr->compress_len = 0;  
 }  
458    
459  void rdp_make_general_caps(RDP_GENERAL_CAPS *caps)          out_uint16(s, 0);       /* Control capabilities */
460  {          out_uint16(s, 0);       /* Remote detach */
461          caps->os_major_type = 1;          out_uint16_le(s, 2);    /* Control interest */
462          caps->os_minor_type = 3;          out_uint16_le(s, 2);    /* Detach interest */
         caps->ver_protocol = 0x200;  
463  }  }
464    
465  void rdp_make_bitmap_caps(RDP_BITMAP_CAPS *caps)  /* Output activation capability set */
466    static void
467    rdp_out_activate_caps(STREAM s)
468  {  {
469          caps->preferred_bpp = 8;          out_uint16_le(s, RDP_CAPSET_ACTIVATE);
470          caps->receive1bpp = 1;          out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
471          caps->receive4bpp = 1;  
472          caps->receive8bpp = 1;          out_uint16(s, 0);       /* Help key */
473          caps->width = 640;          out_uint16(s, 0);       /* Help index key */
474          caps->height = 480;          out_uint16(s, 0);       /* Extended help key */
475          caps->compression = 1;          out_uint16(s, 0);       /* Window activate */
         caps->unknown2 = 1;  
476  }  }
477    
478  void rdp_make_order_caps(RDP_ORDER_CAPS *caps)  /* Output pointer capability set */
479    static void
480    rdp_out_pointer_caps(STREAM s)
481  {  {
482          caps->xgranularity = 1;          out_uint16_le(s, RDP_CAPSET_POINTER);
483          caps->ygranularity = 20;          out_uint16_le(s, RDP_CAPLEN_POINTER);
         caps->max_order_level = 1;  
         caps->num_fonts = 0x147;  
         caps->cap_flags = 0x2A;  
   
 //      caps->cap_flags = ORDER_CAP_NEGOTIATE | ORDER_CAP_NOSUPPORT;  
484    
485          caps->support[0] = caps->support[1] = caps->support[2]          out_uint16(s, 0);       /* Colour pointer */
486                  = caps->support[3] = caps->support[4] = caps->support[5]          out_uint16_le(s, 20);   /* Cache size */
                 = caps->support[6] = caps->support[8] = caps->support[11]  
                 = caps->support[12] = caps->support[22] = caps->support[28]  
                 = caps->support[29] = caps->support[30] = 1;  
         caps->text_cap_flags = 0x6A1;  
         caps->desk_save_size = 0x38400;  
         caps->unknown2 = 0x4E4;  
487  }  }
488    
489  void rdp_make_bmpcache_caps(RDP_BMPCACHE_CAPS *caps)  /* Output share capability set */
490    static void
491    rdp_out_share_caps(STREAM s)
492  {  {
493          caps->caches[0].entries = 0x258;          out_uint16_le(s, RDP_CAPSET_SHARE);
494          caps->caches[0].max_cell_size = 0x100;          out_uint16_le(s, RDP_CAPLEN_SHARE);
         caps->caches[1].entries = 0x12c;  
         caps->caches[1].max_cell_size = 0x400;  
         caps->caches[2].entries = 0x106;  
         caps->caches[2].max_cell_size = 0x1000;  
 }  
495    
496  void rdp_make_control_caps(RDP_CONTROL_CAPS *caps)          out_uint16(s, 0);       /* userid */
497  {          out_uint16(s, 0);       /* pad */
         caps->control_interest = 2;  
         caps->detach_interest = 2;  
498  }  }
499    
500  void rdp_make_activate_caps(RDP_ACTIVATE_CAPS *caps)  /* Output colour cache capability set */
501    static void
502    rdp_out_colcache_caps(STREAM s)
503  {  {
504  }          out_uint16_le(s, RDP_CAPSET_COLCACHE);
505            out_uint16_le(s, RDP_CAPLEN_COLCACHE);
506    
507  void rdp_make_pointer_caps(RDP_POINTER_CAPS *caps)          out_uint16_le(s, 6);    /* cache size */
508  {          out_uint16(s, 0);       /* pad */
         caps->colour_pointer = 0;  
         caps->cache_size = 20;  
509  }  }
510    
511  void rdp_make_share_caps(RDP_SHARE_CAPS *caps, uint16 userid)  static uint8 canned_caps[] = {
512  {          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
513  }          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
514            0x00, 0x00, 0x00, 0x00, 0x00,
515            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
516            0x00, 0x00, 0x00, 0x00, 0x00,
517            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
518            0x00, 0x00, 0x00, 0x00, 0x00,
519            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
520            0x00, 0x00, 0x00, 0x00, 0x00,
521            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
522            0x0C, 0x00, 0x08, 0x00, 0x01,
523            0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
524            0x10, 0x00, 0x34, 0x00, 0xFE,
525            0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
526            0xFE, 0x00, 0x08, 0x00, 0xFE,
527            0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
528            0xFE, 0x00, 0x80, 0x00, 0xFE,
529            0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
530            0x02, 0x00, 0x00, 0x00
531    };
532    
533  void rdp_make_colcache_caps(RDP_COLCACHE_CAPS *caps)  /* Output unknown capability sets (number 13, 12, 14 and 16) */
534    static void
535    rdp_out_unknown_caps(STREAM s)
536    {
537            out_uint16_le(s, RDP_CAPSET_UNKNOWN);
538            out_uint16_le(s, 0x58);
539    
540            out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);
541    }
542    
543    #define RDP5_FLAG 0x0030
544    /* Send a confirm active PDU */
545    static void
546    rdp_send_confirm_active(void)
547    {
548            STREAM s;
549            uint32 sec_flags = encryption ? (RDP5_FLAG | SEC_ENCRYPT) : RDP5_FLAG;
550            uint16 caplen =
551                    RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
552                    RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
553                    RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
554                    RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
555    
556            s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
557    
558            out_uint16_le(s, 2 + 14 + caplen + sizeof(RDP_SOURCE));
559            out_uint16_le(s, (RDP_PDU_CONFIRM_ACTIVE | 0x10));      /* Version 1 */
560            out_uint16_le(s, (g_mcs_userid + 1001));
561    
562            out_uint32_le(s, rdp_shareid);
563            out_uint16_le(s, 0x3ea);        /* userid */
564            out_uint16_le(s, sizeof(RDP_SOURCE));
565            out_uint16_le(s, caplen);
566    
567            out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));
568            out_uint16_le(s, 0xd);  /* num_caps */
569            out_uint8s(s, 2);       /* pad */
570    
571            rdp_out_general_caps(s);
572            rdp_out_bitmap_caps(s);
573            rdp_out_order_caps(s);
574            rdp_out_bmpcache_caps(s);
575            rdp_out_colcache_caps(s);
576            rdp_out_activate_caps(s);
577            rdp_out_control_caps(s);
578            rdp_out_pointer_caps(s);
579            rdp_out_share_caps(s);
580            rdp_out_unknown_caps(s);
581    
582            s_mark_end(s);
583            sec_send(s, sec_flags);
584    }
585    
586    /* Respond to a demand active PDU */
587    static void
588    process_demand_active(STREAM s)
589  {  {
590          caps->cache_size = 6;          uint8 type;
 }  
591    
592  void rdp_make_active_pdu(RDP_ACTIVE_PDU *pdu, uint32 shareid, uint16 userid)          in_uint32_le(s, rdp_shareid);
 {  
         memset(pdu, 0, sizeof(*pdu));  
         pdu->shareid = shareid;  
         pdu->userid  = 1002;  
         pdu->source_len = sizeof(RDP_SOURCE);  
         memcpy(pdu->source, RDP_SOURCE, sizeof(RDP_SOURCE));  
593    
594          pdu->caps_len = RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));
                 + 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;  
595    
596          rdp_make_general_caps (&pdu->general_caps );          rdp_send_confirm_active();
597          rdp_make_bitmap_caps  (&pdu->bitmap_caps  );          rdp_send_synchronise();
598          rdp_make_order_caps   (&pdu->order_caps   );          rdp_send_control(RDP_CTL_COOPERATE);
599          rdp_make_bmpcache_caps(&pdu->bmpcache_caps);          rdp_send_control(RDP_CTL_REQUEST_CONTROL);
600          rdp_make_control_caps (&pdu->control_caps );          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
601          rdp_make_activate_caps(&pdu->activate_caps);          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
602          rdp_make_pointer_caps (&pdu->pointer_caps );          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
603          rdp_make_share_caps   (&pdu->share_caps, userid);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);
604          rdp_make_colcache_caps(&pdu->colcache_caps);          rdp_send_fonts(1);
605            rdp_send_fonts(2);
606            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
607            reset_order_state();
608  }  }
609    
610  void rdp_make_control_pdu(RDP_CONTROL_PDU *pdu, uint16 action)  /* Process a null system pointer PDU */
611    void
612    process_null_system_pointer_pdu(STREAM s)
613  {  {
614          pdu->action = action;          // FIXME: We should probably set another cursor here,
615          pdu->userid = 0;          // like the X window system base cursor or something.
616          pdu->controlid = 0;          ui_set_cursor(cache_get_cursor(0));
617  }  }
618    
619  void rdp_make_synchronize_pdu(RDP_SYNCHRONIZE_PDU *pdu, uint16 userid)  /* Process a colour pointer PDU */
620    void
621    process_colour_pointer_pdu(STREAM s)
622  {  {
623          pdu->type = 1;          uint16 x, y, width, height, cache_idx, masklen, datalen;
624          pdu->userid = userid;          uint8 *mask, *data;
625  }          HCURSOR cursor;
626    
627  void rdp_make_font_pdu(RDP_FONT_PDU *pdu, uint16 seqno)          in_uint16_le(s, cache_idx);
628  {          in_uint16_le(s, x);
629          pdu->num_fonts = 0;          in_uint16_le(s, y);
630          pdu->unknown1 = 0x3e;          in_uint16_le(s, width);
631          pdu->unknown2 = seqno;          in_uint16_le(s, height);
632          pdu->entry_size = RDP_FONT_INFO_SIZE;          in_uint16_le(s, masklen);
633            in_uint16_le(s, datalen);
634            in_uint8p(s, data, datalen);
635            in_uint8p(s, mask, masklen);
636            cursor = ui_create_cursor(x, y, width, height, mask, data);
637            ui_set_cursor(cursor);
638            cache_put_cursor(cache_idx, cursor);
639  }  }
640    
641  void rdp_make_input_pdu(RDP_INPUT_PDU *pdu)  /* Process a cached pointer PDU */
642    void
643    process_cached_pointer_pdu(STREAM s)
644  {  {
645          uint32 now = time(NULL);          uint16 cache_idx;
   
         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;  
646    
647          pdu->event[2].event_time = now;          in_uint16_le(s, cache_idx);
648          pdu->event[2].message_type = RDP_INPUT_MOUSE;          ui_set_cursor(cache_get_cursor(cache_idx));
         pdu->event[2].device_flags = MOUSE_FLAG_MOVE;  
         pdu->event[2].mouse_x = 425;  
         pdu->event[2].mouse_y = 493;  
649  }  }
650    
 BOOL rdp_io_header(STREAM s, RDP_HEADER *hdr)  
 {  
         BOOL res = True;  
   
         res = res ? lsb_io_uint16(s, &hdr->length  ) : False;  
         res = res ? lsb_io_uint16(s, &hdr->pdu_type) : False;  
         res = res ? lsb_io_uint16(s, &hdr->userid  ) : False;  
651    
652          return res;  /* Process a pointer PDU */
653  }  static void
654    process_pointer_pdu(STREAM s)
 BOOL rdp_io_data_header(STREAM s, RDP_DATA_HEADER *hdr)  
655  {  {
656          BOOL res = True;          uint16 message_type;
657            uint16 x, y;
658    
659          res = res ? lsb_io_uint32(s, &hdr->shareid      ) : False;          in_uint16_le(s, message_type);
660          res = res ? prs_io_uint8 (s, &hdr->pad          ) : False;          in_uint8s(s, 2);        /* pad */
         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;  
661    
662          return res;          switch (message_type)
 }  
   
 BOOL rdp_io_coord(STREAM s, uint16 *coord, BOOL delta)  
 {  
         uint8 change;  
         BOOL res;  
   
         if (delta)  
         {  
                 res = prs_io_uint8(s, &change);  
                 *coord += change;  
         }  
         else  
663          {          {
664                  res = lsb_io_uint16(s, coord);                  case RDP_POINTER_MOVE:
665          }                          in_uint16_le(s, x);
666                            in_uint16_le(s, y);
667          return res;                          if (s_check(s))
668  }                                  ui_move_pointer(x, y);
669                            break;
 BOOL rdp_io_colormap(STREAM s, COLORMAP *colors)  
 {  
         int datasize;  
670    
671          lsb_io_uint16(s, &colors->ncolors);                  case RDP_POINTER_COLOR:
672          datasize = colors->ncolors * 3;                          process_colour_pointer_pdu(s);
673                            break;
674    
675          if (datasize > sizeof(colors->colors))                  case RDP_POINTER_CACHED:
676                  return False;                          process_cached_pointer_pdu(s);
677                            break;
678    
679          memcpy(colors->colors, s->data + s->offset, datasize);                  default:
680          s->offset += datasize;                          DEBUG(("Pointer message 0x%x\n", message_type));
681          return True;          }
682  }  }
683    
684  BOOL rdp_io_general_caps(STREAM s, RDP_GENERAL_CAPS *caps)  /* Process bitmap updates */
685    void
686    process_bitmap_updates(STREAM s)
687  {  {
688          uint16 length = RDP_CAPLEN_GENERAL;          uint16 num_updates;
689          uint16 pkt_length = length;          uint16 left, top, right, bottom, width, height;
690          BOOL res;          uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
691            uint8 *data, *bmpdata;
692          res = lsb_io_uint16(s, &pkt_length);          int i;
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
693    
694          res = res ? lsb_io_uint16(s, &caps->os_major_type ) : False;          in_uint16_le(s, num_updates);
         res = res ? lsb_io_uint16(s, &caps->os_minor_type ) : False;  
         res = res ? lsb_io_uint16(s, &caps->ver_protocol  ) : False;  
         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;  
695    
696          res = lsb_io_uint16(s, &pkt_length);          for (i = 0; i < num_updates; i++)
         if (pkt_length != length)  
697          {          {
698                  fprintf(stderr, "Unrecognised capabilities size\n");                  in_uint16_le(s, left);
699                  return False;                  in_uint16_le(s, top);
700          }                  in_uint16_le(s, right);
701                    in_uint16_le(s, bottom);
702                    in_uint16_le(s, width);
703                    in_uint16_le(s, height);
704                    in_uint16_le(s, bpp);
705                    Bpp = (bpp + 7) / 8;
706                    in_uint16_le(s, compress);
707                    in_uint16_le(s, bufsize);
708    
709          res = res ? lsb_io_uint16(s, &caps->preferred_bpp) : False;                  cx = right - left + 1;
710          res = res ? lsb_io_uint16(s, &caps->receive1bpp  ) : False;                  cy = bottom - top + 1;
         res = res ? lsb_io_uint16(s, &caps->receive4bpp  ) : False;  
         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;  
711    
712          res = lsb_io_uint16(s, &pkt_length);                  DEBUG(("BITMAP_UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,Bpp=%d,cmp=%d)\n",
713          if (pkt_length != length)                         left, top, right, bottom, width, height, Bpp, compress));
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
   
         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;  
714    
715          return res;                  if (!compress)
716  }                  {
717                            int y;
718                            bmpdata = (uint8 *) xmalloc(width * height * Bpp);
719                            for (y = 0; y < height; y++)
720                            {
721                                    in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
722                                              width * Bpp);
723                            }
724                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
725                            xfree(bmpdata);
726                            continue;
727                    }
728    
 BOOL rdp_io_bmpcache_info(STREAM s, RDP_BMPCACHE_INFO *info)  
 {  
         if (!lsb_io_uint16(s, &info->entries      ))  
                 return False;  
729    
730          if (!lsb_io_uint16(s, &info->max_cell_size))                  if (compress & 0x400)
731                  return False;                  {
732                            size = bufsize;
733                    }
734                    else
735                    {
736                            in_uint8s(s, 2);        /* pad */
737                            in_uint16_le(s, size);
738                            in_uint8s(s, 4);        /* line_size, final_size */
739                    }
740                    in_uint8p(s, data, size);
741                    bmpdata = (uint8 *) xmalloc(width * height * Bpp);
742                    if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
743                    {
744                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
745                    }
746                    else
747                    {
748                            DEBUG_RDP5(("Failed to decompress data\n"));
749                    }
750    
751          return True;                  xfree(bmpdata);
752            }
753  }  }
754    
755  BOOL rdp_io_bmpcache_caps(STREAM s, RDP_BMPCACHE_CAPS *caps)  /* Process a palette update */
756    void
757    process_palette(STREAM s)
758  {  {
759          uint16 length = RDP_CAPLEN_BMPCACHE;          COLOURENTRY *entry;
760          uint16 pkt_length = length;          COLOURMAP map;
761          BOOL res;          HCOLOURMAP hmap;
762          int i;          int i;
763    
764          res = lsb_io_uint16(s, &pkt_length);          in_uint8s(s, 2);        /* pad */
765          if (pkt_length != length)          in_uint16_le(s, map.ncolours);
766          {          in_uint8s(s, 2);        /* pad */
                 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;  
767    
768          return res;          map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
 }  
769    
770  BOOL rdp_io_control_caps(STREAM s, RDP_CONTROL_CAPS *caps)          DEBUG(("PALETTE(c=%d)\n", map.ncolours));
 {  
         uint16 length = RDP_CAPLEN_CONTROL;  
         uint16 pkt_length = length;  
         BOOL res;  
771    
772          res = lsb_io_uint16(s, &pkt_length);          for (i = 0; i < map.ncolours; i++)
         if (pkt_length != length)  
773          {          {
774                  fprintf(stderr, "Unrecognised capabilities size\n");                  entry = &map.colours[i];
775                  return False;                  in_uint8(s, entry->red);
776                    in_uint8(s, entry->green);
777                    in_uint8(s, entry->blue);
778          }          }
779    
780          res = res ? lsb_io_uint16(s, &caps->control_caps    ) : False;          hmap = ui_create_colourmap(&map);
781          res = res ? lsb_io_uint16(s, &caps->remote_detach   ) : False;          ui_set_colourmap(hmap);
         res = res ? lsb_io_uint16(s, &caps->control_interest) : False;  
         res = res ? lsb_io_uint16(s, &caps->detach_interest ) : False;  
782    
783          return res;          xfree(map.colours);
784  }  }
785    
786  BOOL rdp_io_activate_caps(STREAM s, RDP_ACTIVATE_CAPS *caps)  /* Process an update PDU */
787    static void
788    process_update_pdu(STREAM s)
789  {  {
790          uint16 length = RDP_CAPLEN_ACTIVATE;          uint16 update_type, count;
         uint16 pkt_length = length;  
         BOOL res;  
791    
792          res = lsb_io_uint16(s, &pkt_length);          in_uint16_le(s, update_type);
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
   
         res = res ? lsb_io_uint16(s, &caps->help_key         ) : False;  
         res = res ? lsb_io_uint16(s, &caps->help_index_key   ) : False;  
         res = res ? lsb_io_uint16(s, &caps->help_extended_key) : False;  
         res = res ? lsb_io_uint16(s, &caps->window_activate  ) : False;  
   
         return res;  
 }  
793    
794  BOOL rdp_io_pointer_caps(STREAM s, RDP_POINTER_CAPS *caps)          switch (update_type)
 {  
         uint16 length = RDP_CAPLEN_POINTER;  
         uint16 pkt_length = length;  
         BOOL res;  
   
         res = lsb_io_uint16(s, &pkt_length);  
         if (pkt_length != length)  
795          {          {
796                  fprintf(stderr, "Unrecognised capabilities size\n");                  case RDP_UPDATE_ORDERS:
797                  return False;                          in_uint8s(s, 2);        /* pad */
798          }                          in_uint16_le(s, count);
799                            in_uint8s(s, 2);        /* pad */
800                            process_orders(s, count);
801                            break;
802    
803          res = res ? lsb_io_uint16(s, &caps->colour_pointer) : False;                  case RDP_UPDATE_BITMAP:
804          res = res ? lsb_io_uint16(s, &caps->cache_size    ) : False;                          process_bitmap_updates(s);
805                            break;
806    
807          return res;                  case RDP_UPDATE_PALETTE:
808  }                          process_palette(s);
809                            break;
810    
811  BOOL rdp_io_share_caps(STREAM s, RDP_SHARE_CAPS *caps)                  case RDP_UPDATE_SYNCHRONIZE:
812  {                          break;
         uint16 length = RDP_CAPLEN_SHARE;  
         uint16 pkt_length = length;  
         BOOL res;  
813    
814          res = lsb_io_uint16(s, &pkt_length);                  default:
815          if (pkt_length != length)                          unimpl("update %d\n", update_type);
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
816          }          }
817    
         res = res ? lsb_io_uint16(s, &caps->userid) : False;  
         res = res ? lsb_io_uint16(s, &caps->pad   ) : False;  
   
         return res;  
818  }  }
819    
820  BOOL rdp_io_colcache_caps(STREAM s, RDP_COLCACHE_CAPS *caps)  /* Process data PDU */
821    static void
822    process_data_pdu(STREAM s)
823  {  {
824          uint16 length = RDP_CAPLEN_COLCACHE;          uint8 data_pdu_type;
         uint16 pkt_length = length;  
         BOOL res;  
825    
826          res = lsb_io_uint16(s, &pkt_length);          in_uint8s(s, 8);        /* shareid, pad, streamid, length */
827          if (pkt_length != length)          in_uint8(s, data_pdu_type);
828          {          in_uint8s(s, 3);        /* compress_type, compress_len */
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
829    
830          res = res ? lsb_io_uint16(s, &caps->cache_size) : False;          switch (data_pdu_type)
831          res = res ? lsb_io_uint16(s, &caps->pad       ) : False;          {
832                    case RDP_DATA_PDU_UPDATE:
833                            process_update_pdu(s);
834                            break;
835    
836          return res;                  case RDP_DATA_PDU_POINTER:
837  }                          process_pointer_pdu(s);
838                            break;
839    
840  uint8 canned_caps[] = {                  case RDP_DATA_PDU_BELL:
841  0x01,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x04,                          ui_bell();
842  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,                          break;
 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  
 };  
843    
844  BOOL rdp_io_unknown_caps(STREAM s, void *caps)                  case RDP_DATA_PDU_LOGON:
845  {                          DEBUG(("Received Logon PDU\n"));
846          uint16 length = 0x58;                          /* User logged on */
847          uint16 pkt_length = length;                          break;
         BOOL res;  
848    
849          res = lsb_io_uint16(s, &pkt_length);                  default:
850          if (pkt_length != length)                          unimpl("data PDU %d\n", data_pdu_type);
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
851          }          }
   
         res = res ? prs_io_uint8s(s, canned_caps, RDP_CAPLEN_UNKNOWN-4) : False;  
   
         return res;  
852  }  }
853    
854  BOOL rdp_io_active_pdu(STREAM s, RDP_ACTIVE_PDU *pdu, int pdutype)  /* Process incoming packets */
855    BOOL
856    rdp_main_loop(void)
857  {  {
858          uint16 capset;          uint8 type;
859          uint16 length;          STREAM s;
         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;  
   
         res = res ? lsb_io_uint16(s, &pdu->source_len) : False;  
         res = res ? lsb_io_uint16(s, &pdu->caps_len  ) : False;  
860    
861          if (pdu->source_len > 48)          while ((s = rdp_recv(&type)) != NULL)
862          {          {
863                  fprintf(stderr, "RDP source descriptor too long\n");                  switch (type)
                 return False;  
         }  
   
         res = res ? prs_io_uint8s(s,  pdu->source, pdu->source_len) : False;  
         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  
         {  
                 for (i = 0; i < pdu->num_caps; i++)  
864                  {                  {
865                          if (!res)                          case RDP_PDU_DEMAND_ACTIVE:
866                                  return False;                                  process_demand_active(s);
   
                         if (!lsb_io_uint16(s, &capset))  
                                 return False;  
   
                         switch (capset)  
                         {  
                         case RDP_CAPSET_GENERAL:  
                                 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 );  
867                                  break;                                  break;
868                          case RDP_CAPSET_SHARE:  
869                                  res = rdp_io_share_caps   (s, &pdu->share_caps   );                          case RDP_PDU_DEACTIVATE:
870                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
871                                    /* We thought we could detect a clean
872                                       shutdown of the session by this
873                                       packet, but it seems Windows 2003
874                                       is sending us one of these when we
875                                       reconnect to a disconnected session
876                                       return True; */
877                                  break;                                  break;
878                          case RDP_CAPSET_COLCACHE:  
879                                  res = rdp_io_colcache_caps(s, &pdu->colcache_caps);                          case RDP_PDU_DATA:
880                                    process_data_pdu(s);
881                                  break;                                  break;
                         default:  
                                 fprintf(stderr, "Warning: Unrecognised capset %x\n",  
                                         capset);  
882    
883                                  if (!lsb_io_uint16(s, &length))                          case 0:
884                                          return False;                                  break;
885    
886                                  s->offset += (length - 4);                          default:
887                          }                                  unimpl("PDU %d\n", type);
888                  }                  }
889          }          }
890            return True;
891          return res;          /* We want to detect if we got a clean shutdown, but we
892  }             can't. Se above.  
893               return False;  */
 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;  
 }  
   
 BOOL rdp_io_input_event(STREAM s, RDP_INPUT_EVENT *evt)  
 {  
         BOOL res = True;  
   
         res = res ? lsb_io_uint32(s, &evt->event_time)   : False;  
         res = res ? lsb_io_uint16(s, &evt->message_type) : False;  
   
         if (!res)  
                 return False;  
   
         switch (evt->message_type)  
         {  
         case RDP_INPUT_CODEPOINT:  
         case RDP_INPUT_VIRTKEY:  
                 res = res ? lsb_io_uint16(s, &evt->device_flags) : False;  
                 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;  
         }  
   
         return res;  
 }  
   
 BOOL rdp_io_input_pdu(STREAM s, RDP_INPUT_PDU *pdu)  
 {  
         BOOL res = True;  
         int i;  
   
         res = res ? lsb_io_uint16(s, &pdu->num_events) : False;  
         res = res ? lsb_io_uint16(s, &pdu->pad       ) : False;  
   
         if (pdu->num_events > RDP_MAX_EVENTS)  
         {  
                 fprintf(stderr, "Too many events in one PDU\n");  
                 return False;  
         }  
   
         for (i = 0; i < pdu->num_events; i++)  
         {  
                 res = res ? rdp_io_input_event(s, &pdu->event[i]) : False;  
         }  
   
         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;  
894  }  }
895    
896  BOOL rdp_io_font_pdu(STREAM s, RDP_FONT_PDU *pdu)  /* Establish a connection up to the RDP layer */
897    BOOL
898    rdp_connect(char *server, uint32 flags, char *domain, char *password,
899                char *command, char *directory)
900  {  {
901          BOOL res = True;          if (!sec_connect(server, username))
         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");  
902                  return False;                  return False;
         }  
903    
904          for (i = 0; i < pdu->num_fonts; i++)          rdp_send_logon_info(flags, domain, username, password, command, directory);
905          {          return True;
                 res = res ? rdp_io_font_info(s, &pdu->font[i]) : False;  
         }  
   
         return res;  
 }  
   
 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;  
   
         return res;  
 }  
   
 BOOL rdp_io_secondary_order(STREAM s, RDP_SECONDARY_ORDER *rso)  
 {  
         BOOL res = True;  
   
         res = res ? lsb_io_uint16(s, &rso->length) : False;  
         res = res ? lsb_io_uint16(s, &rso->flags ) : False;  
         res = res ? prs_io_uint8 (s, &rso->type  ) : False;  
   
         return res;  
 }  
   
 BOOL rdp_io_bitmap_header(STREAM s, RDP_BITMAP_HEADER *rdh)  
 {  
         BOOL res = True;  
   
         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;  
   
         return res;  
906  }  }
907    
908  BOOL rdp_io_pointer(STREAM s, RDP_POINTER *ptr)  /* Disconnect from the RDP layer */
909    void
910    rdp_disconnect(void)
911  {  {
912          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;  
913  }  }
Legend:
Removed from v.7  
changed lines
  Added in v.436
  ViewVC Help
Powered by ViewVC 1.1.26