/[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 340 by forsberg, Thu Mar 6 14:11:17 2003 UTC
# Line 1  Line 1 
1  /*  /*
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
# Line 18  Line 18 
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */  */
20    
21  #include "includes.h"  #include "rdesktop.h"
22    
23  /* Establish a connection up to the RDP layer */  extern uint16 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    
30          if ((conn = mcs_connect(server)) == NULL)  uint8 *next_packet;
31                  return NULL;  uint32 rdp_shareid;
32    
33          rdp_establish_key(conn);  #if WITH_DEBUG
34          mcs_recv(conn, False); /* Server's licensing certificate */  static uint32 packetno;
35          rdp_send_cert(conn);  #endif
         mcs_recv(conn, False);  
         mcs_recv(conn, False); /* Demand active */  
36    
37          if (!rdp_recv_pdu(conn, &type) || (type != RDP_PDU_DEMAND_ACTIVE))  /* Initialise an RDP packet */
38          {  static STREAM
39                  fprintf(stderr, "RDP error, expected Demand Active\n");  rdp_init(int maxlen)
40                  mcs_disconnect(conn);  {
41                  return NULL;          STREAM s;
         }  
42    
43          rdp_io_active_pdu(&conn->in, &active, RDP_PDU_DEMAND_ACTIVE);          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 6);
44          rdp_send_confirm_active(conn);          s_push_layer(s, rdp_hdr, 6);
         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  
45    
46          return conn;          return s;
47  }  }
48    
49  void rdp_main_loop(HCONN conn)  /* Send an RDP packet */
50    static void
51    rdp_send(STREAM s, uint8 pdu_type)
52  {  {
53          RDP_DATA_HEADER hdr;          uint16 length;
         RDP_ORDER_STATE os;  
         uint8 type;  
   
         memset(&os, 0, sizeof(os));  
   
         while (rdp_recv_pdu(conn, &type))  
         {  
                 if (type != RDP_PDU_DATA)  
                 {  
                         fprintf(stderr, "Unknown PDU 0x%x\n", type);  
                         continue;  
                 }  
   
                 rdp_io_data_header(&conn->in, &hdr);  
54    
55                  switch (hdr.data_pdu_type)          s_pop_layer(s, rdp_hdr);
56                  {          length = s->end - s->p;
                         case RDP_DATA_PDU_UPDATE:  
                                 process_update(conn, &os);  
                                 break;  
57    
58                          case RDP_DATA_PDU_POINTER:          out_uint16_le(s, length);
59                                  process_pointer(conn);          out_uint16_le(s, (pdu_type | 0x10));    /* Version 1 */
60                                  break;          out_uint16_le(s, (mcs_userid + 1001));
61    
62                          default:          sec_send(s, encryption ? SEC_ENCRYPT : 0);
                                 fprintf(stderr, "Unknown data PDU 0x%x\n",  
                                                 hdr.data_pdu_type);  
                 }  
         }  
63  }  }
64    
65  void process_memblt(HCONN conn, RDP_ORDER_STATE *os, BOOL delta)  /* Receive an RDP packet */
66    static STREAM
67    rdp_recv(uint8 * type)
68  {  {
69          HBITMAP hbitmap;          static STREAM rdp_s;
70          uint16 present;          uint16 length, pdu_type;
         lsb_io_uint16(&conn->in, &present);  
71    
72          if (present & 1)          if ((rdp_s == NULL) || (next_packet >= rdp_s->end))
                 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 */  
73          {          {
74                  fprintf(stderr, "Unsupported raster operation 0x%x\n",                  rdp_s = sec_recv();
75                          os->memblt.opcode);                  if (rdp_s == NULL)
76                  return;                          return NULL;
         }  
77    
78          if ((os->memblt.cache_idx > NUM_ELEMENTS(conn->bmpcache))                  next_packet = rdp_s->p;
             || ((hbitmap = conn->bmpcache[os->memblt.cache_idx]) == NULL))  
         {  
                 fprintf(stderr, "Bitmap %d not found\n", os->memblt.cache_idx);  
                 return;  
79          }          }
80            else
         fprintf(stderr, "MEMBLT %d:%dx%d\n", os->memblt.cache_idx,  
                                         os->memblt.x, os->memblt.y);  
   
         ui_paint_bitmap(conn->wnd, hbitmap, os->memblt.x, os->memblt.y);  
 }  
   
 void process_opaque_rect(HCONN conn, RDP_ORDER_STATE *os, BOOL delta)  
 {  
         uint8 present;  
         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);  
   
         if (present & 8)  
                 rdp_io_coord(&conn->in, &os->opaque_rect.cy, delta);  
   
         if (present & 16)  
                 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);  
 }  
   
 void process_bmpcache(HCONN conn)  
 {  
         RDP_BITMAP_HEADER rbh;  
         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);  
   
         input = conn->in.data + conn->in.offset;  
         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))  
81          {          {
82                  fprintf(stderr, "Decompression failed\n");                  rdp_s->p = next_packet;
                 free(bmpdata);  
                 return;  
83          }          }
84    
85          if (rbh.cache_idx > NUM_ELEMENTS(conn->bmpcache))          in_uint16_le(rdp_s, length);
86            /* 32k packets are really 8, keepalive fix */
87            if (length == 0x8000)
88          {          {
89                  fprintf(stderr, "Attempted store past end of cache");                  next_packet += 8;
90                  return;                  *type = 0;
91                    return rdp_s;
92          }          }
93            in_uint16_le(rdp_s, pdu_type);
94            in_uint8s(rdp_s, 2);    /* userid */
95            *type = pdu_type & 0xf;
96    
97          entry = &conn->bmpcache[rbh.cache_idx];  #if WITH_DEBUG
98          // if (*entry != NULL)          DEBUG(("RDP packet #%d, (type %x):\n", ++packetno, *type));
99          //      ui_destroy_bitmap(conn->wnd, *entry);          hexdump(next_packet, length);
100    #endif /*  */
101    
102          *entry = ui_create_bitmap(conn->wnd, rbh.width, rbh.height, bmpdata);          next_packet += length;
103          //      ui_paint_bitmap(conn->wnd, bmp, x, 0);          return rdp_s;
         //      ui_destroy_bitmap(conn->wnd, bmp);  
104  }  }
105    
106  void process_orders(HCONN conn, RDP_ORDER_STATE *os)  /* Initialise an RDP data packet */
107    static STREAM
108    rdp_init_data(int maxlen)
109  {  {
110          uint16 num_orders;          STREAM s;
         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)  
         {  
                 uint8 order_flags;  
111    
112                  prs_io_uint8(&conn->in, &order_flags);          s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);
113                  fprintf(stderr, "Order flags: 0x%x\n", order_flags);          s_push_layer(s, rdp_hdr, 18);
114    
115                  if (order_flags == 0x51) /* ?? */          return s;
                         return;  
   
                 if (!(order_flags & RDP_ORDER_STANDARD))  
                         return;  
   
                 if (order_flags & RDP_ORDER_SECONDARY)  
                 {  
                         RDP_SECONDARY_ORDER rso;  
   
                         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;  
                         }  
                 }  
                 else  
                 {  
                         if (order_flags & RDP_ORDER_CHANGE)  
                                 prs_io_uint8(&conn->in, &os->order_type);  
   
                         delta = order_flags & RDP_ORDER_DELTA;  
   
                         switch (os->order_type)  
                         {  
                         case RDP_ORDER_OPAQUE_RECT:  
                                 process_opaque_rect(conn, os, delta);  
                                 break;  
   
                         case RDP_ORDER_MEMBLT:  
                                 process_memblt(conn, os, delta);  
                                 break;  
   
                         default:  
                                 fprintf(stderr, "Unknown order %d\n", os->order_type);  
                                 return;  
                         }  
                 }  
   
                 processed++;  
         }  
116  }  }
117    
118  void process_palette(HCONN conn)  /* Send an RDP data packet */
119    static void
120    rdp_send_data(STREAM s, uint8 data_pdu_type)
121  {  {
122          HCOLORMAP map;          uint16 length;
         COLORMAP colors;  
123    
124          rdp_io_colormap(&conn->in, &colors);          s_pop_layer(s, rdp_hdr);
125          map = ui_create_colormap(conn->wnd, &colors);          length = s->end - s->p;
         ui_set_colormap(conn->wnd, map);  
         // ui_destroy_colormap(map);  
 }  
126    
127  void process_update(HCONN conn, RDP_ORDER_STATE *os)          out_uint16_le(s, length);
128  {          out_uint16_le(s, (RDP_PDU_DATA | 0x10));
129          RDP_UPDATE_PDU update;          out_uint16_le(s, (mcs_userid + 1001));
130    
131          rdp_io_update_pdu(&conn->in, &update);          out_uint32_le(s, rdp_shareid);
132          switch (update.update_type)          out_uint8(s, 0);        /* pad */
133          {          out_uint8(s, 1);        /* streamid */
134                  case RDP_UPDATE_ORDERS:          out_uint16_le(s, (length - 14));
135                          process_orders(conn, os);          out_uint8(s, data_pdu_type);
136                          break;          out_uint8(s, 0);        /* compress_type */
137                  case RDP_UPDATE_PALETTE:          out_uint16(s, 0);       /* compress_len */
                         process_palette(conn);  
                         break;  
                 case RDP_UPDATE_SYNCHRONIZE:  
                         break;  
                 default:  
                         fprintf(stderr, "Unknown update 0x%x\n",  
                                 update.update_type);  
         }  
138    
139            sec_send(s, encryption ? SEC_ENCRYPT : 0);
140  }  }
141    
142  void process_pointer(HCONN conn)  /* Output a string in Unicode */
143    void
144    rdp_out_unistr(STREAM s, char *string, int len)
145  {  {
146          RDP_POINTER ptr;          int i = 0, j = 0;
147    
148          rdp_io_pointer(&conn->in, &ptr);          len += 2;
149    
150          switch (ptr.message)          while (i < len)
151          {          {
152                  case RDP_POINTER_MOVE:                  s->p[i++] = string[j++];
153                          ui_move_pointer(conn->wnd, ptr.x, ptr.y);                  s->p[i++] = 0;
                         break;  
                 default:  
                         fprintf(stderr, "Unknown pointer message 0x%x\n",  
                                 ptr.message);  
154          }          }
 }  
   
 /* Work this out later. This is useless anyway when encryption is off. */  
 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  
 };  
   
 /* Create an RC4 key and transfer it to the server */  
 void rdp_establish_key(HCONN conn)  
 {  
         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  
 };  
   
 /* Send license certificate and related data to the server */  
 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);  
 }  
   
 /* Initialise RDP transport packet */  
 void rdp_init(HCONN conn)  
 {  
         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;  
155    
156          POP_LAYER(conn->out, rdp_offset);          s->p += len;
         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);  
157  }  }
158    
159  /* Initialise RDP transport data packet */  /* Parse a logon info packet */
160  void rdp_init_data(HCONN conn)  static void
161    rdp_send_logon_info(uint32 flags, char *domain, char *user,
162                        char *password, char *program, char *directory)
163  {  {
164          mcs_init_data(conn);          int len_domain = 2 * strlen(domain);
165          PUSH_LAYER(conn->out, rdp_offset, 18);          int len_user = 2 * strlen(user);
166  }          int len_password = 2 * strlen(password);
167            int len_program = 2 * strlen(program);
168  /* Transmit RDP transport data packet */          int len_directory = 2 * strlen(directory);
169  void rdp_send_data(HCONN conn, uint16 data_pdu_type)          uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
170  {          STREAM s;
         RDP_HEADER hdr;  
         RDP_DATA_HEADER datahdr;  
         int length = conn->out.end - conn->out.offset;  
171    
172          POP_LAYER(conn->out, rdp_offset);          s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
173          length = conn->out.end - conn->out.offset;                       + len_program + len_directory + 10);
         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);  
 }  
174    
175  void rdp_send_confirm_active(HCONN conn)          out_uint32(s, 0);
176  {          out_uint32_le(s, flags);
177          RDP_ACTIVE_PDU active;          out_uint16_le(s, len_domain);
178            out_uint16_le(s, len_user);
179            out_uint16_le(s, len_password);
180            out_uint16_le(s, len_program);
181            out_uint16_le(s, len_directory);
182            rdp_out_unistr(s, domain, len_domain);
183            rdp_out_unistr(s, user, len_user);
184            rdp_out_unistr(s, password, len_password);
185            rdp_out_unistr(s, program, len_program);
186            rdp_out_unistr(s, directory, len_directory);
187    
188          rdp_init(conn);          s_mark_end(s);
189          rdp_make_active_pdu(&active, 0x103ea, conn->mcs_userid);          sec_send(s, sec_flags);
         rdp_io_active_pdu(&conn->out, &active, RDP_PDU_CONFIRM_ACTIVE);  
         MARK_END(conn->out);  
         rdp_send(conn, RDP_PDU_CONFIRM_ACTIVE);  
190  }  }
191    
192  void rdp_send_synchronize(HCONN conn)  /* Send a control PDU */
193    static void
194    rdp_send_control(uint16 action)
195  {  {
196          RDP_SYNCHRONIZE_PDU sync;          STREAM s;
197    
198          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);  
 }  
199    
200  void rdp_send_control(HCONN conn, uint16 action)          out_uint16_le(s, action);
201  {          out_uint16(s, 0);       /* userid */
202          RDP_CONTROL_PDU control;          out_uint32(s, 0);       /* control id */
203    
204          rdp_init_data(conn);          s_mark_end(s);
205          rdp_make_control_pdu(&control, action);          rdp_send_data(s, RDP_DATA_PDU_CONTROL);
         rdp_io_control_pdu(&conn->out, &control);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_CONTROL);  
206  }  }
207    
208  void rdp_send_fonts(HCONN conn, uint16 seqno)  /* Send a synchronisation PDU */
209    static void
210    rdp_send_synchronise(void)
211  {  {
212          RDP_FONT_PDU fonts;          STREAM s;
213    
214          rdp_init_data(conn);          s = rdp_init_data(4);
         rdp_make_font_pdu(&fonts, seqno);  
         rdp_io_font_pdu(&conn->out, &fonts);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_FONT2);  
 }  
215    
216  void rdp_send_input(HCONN conn)          out_uint16_le(s, 1);    /* type */
217  {          out_uint16_le(s, 1002);
         RDP_INPUT_PDU input;  
218    
219          rdp_init_data(conn);          s_mark_end(s);
220          rdp_make_input_pdu(&input);          rdp_send_data(s, RDP_DATA_PDU_SYNCHRONISE);
         rdp_io_input_pdu(&conn->out, &input);  
         MARK_END(conn->out);  
         rdp_send_data(conn, RDP_DATA_PDU_INPUT);  
221  }  }
222    
223  BOOL rdp_recv_pdu(HCONN conn, uint8 *type)  /* Send a single input event */
224    void
225    rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
226  {  {
227          RDP_HEADER hdr;          STREAM s;
228    
229          conn->in.offset = conn->in.rdp_offset;          s = rdp_init_data(16);
230    
231          if (conn->in.offset >= conn->in.end)          out_uint16_le(s, 1);    /* number of events */
232          {          out_uint16(s, 0);       /* pad */
                 if (!mcs_recv(conn, False))  
                         return False;  
         }  
233    
234          if (!rdp_io_header(&conn->in, &hdr))          out_uint32_le(s, time);
235                  return False;          out_uint16_le(s, message_type);
236            out_uint16_le(s, device_flags);
237          conn->in.rdp_offset += hdr.length;          out_uint16_le(s, param1);
238          *type = hdr.pdu_type & 0xf;          out_uint16_le(s, param2);
   
 #if DEBUG  
         fprintf(stderr, "RDP packet (type %x):\n", *type);  
         dump_data(conn->in.data+conn->in.offset, conn->in.rdp_offset-conn->in.offset);  
 #endif  
239    
240          return True;          s_mark_end(s);
241            rdp_send_data(s, RDP_DATA_PDU_INPUT);
242  }  }
243    
244  /* Disconnect from the RDP layer */  /* Send an (empty) font information PDU */
245  void rdp_disconnect(HCONN conn)  static void
246    rdp_send_fonts(uint16 seq)
247  {  {
248          mcs_disconnect(conn);          STREAM s;
 }  
249    
250  void rdp_make_header(RDP_HEADER *hdr, uint16 length, uint16 pdu_type,          s = rdp_init_data(8);
                      uint16 userid)  
 {  
         hdr->length = length;  
         hdr->pdu_type = pdu_type | 0x10; /* Version 1 */  
         hdr->userid = userid + 1001;  
 }  
251    
252  void rdp_make_data_header(RDP_DATA_HEADER *hdr, uint32 shareid,          out_uint16(s, 0);       /* number of fonts */
253                            uint16 length, uint16 data_pdu_type)          out_uint16_le(s, 0x3e); /* unknown */
254  {          out_uint16_le(s, seq);  /* unknown */
255          hdr->shareid = shareid;          out_uint16_le(s, 0x32); /* entry size */
         hdr->pad = 0;  
         hdr->streamid = 1;  
         hdr->length = length - 14;  
         hdr->data_pdu_type = data_pdu_type;  
         hdr->compress_type = 0;  
         hdr->compress_len = 0;  
 }  
256    
257  void rdp_make_general_caps(RDP_GENERAL_CAPS *caps)          s_mark_end(s);
258  {          rdp_send_data(s, RDP_DATA_PDU_FONT2);
         caps->os_major_type = 1;  
         caps->os_minor_type = 3;  
         caps->ver_protocol = 0x200;  
 }  
   
 void rdp_make_bitmap_caps(RDP_BITMAP_CAPS *caps)  
 {  
         caps->preferred_bpp = 8;  
         caps->receive1bpp = 1;  
         caps->receive4bpp = 1;  
         caps->receive8bpp = 1;  
         caps->width = 640;  
         caps->height = 480;  
         caps->compression = 1;  
         caps->unknown2 = 1;  
259  }  }
260    
261  void rdp_make_order_caps(RDP_ORDER_CAPS *caps)  /* Output general capability set */
262    static void
263    rdp_out_general_caps(STREAM s)
264  {  {
265          caps->xgranularity = 1;          out_uint16_le(s, RDP_CAPSET_GENERAL);
266          caps->ygranularity = 20;          out_uint16_le(s, RDP_CAPLEN_GENERAL);
         caps->max_order_level = 1;  
         caps->num_fonts = 0x147;  
         caps->cap_flags = 0x2A;  
   
 //      caps->cap_flags = ORDER_CAP_NEGOTIATE | ORDER_CAP_NOSUPPORT;  
267    
268          caps->support[0] = caps->support[1] = caps->support[2]          out_uint16_le(s, 1);    /* OS major type */
269                  = caps->support[3] = caps->support[4] = caps->support[5]          out_uint16_le(s, 3);    /* OS minor type */
270                  = caps->support[6] = caps->support[8] = caps->support[11]          out_uint16_le(s, 0x200);        /* Protocol version */
271                  = caps->support[12] = caps->support[22] = caps->support[28]          out_uint16(s, 0);       /* Pad */
272                  = caps->support[29] = caps->support[30] = 1;          out_uint16(s, 0);       /* Compression types */
273          caps->text_cap_flags = 0x6A1;          out_uint16(s, 0);       /* Pad */
274          caps->desk_save_size = 0x38400;          out_uint16(s, 0);       /* Update capability */
275          caps->unknown2 = 0x4E4;          out_uint16(s, 0);       /* Remote unshare capability */
276            out_uint16(s, 0);       /* Compression level */
277            out_uint16(s, 0);       /* Pad */
278  }  }
279    
280  void rdp_make_bmpcache_caps(RDP_BMPCACHE_CAPS *caps)  /* Output bitmap capability set */
281    static void
282    rdp_out_bitmap_caps(STREAM s)
283  {  {
284          caps->caches[0].entries = 0x258;          out_uint16_le(s, RDP_CAPSET_BITMAP);
285          caps->caches[0].max_cell_size = 0x100;          out_uint16_le(s, RDP_CAPLEN_BITMAP);
         caps->caches[1].entries = 0x12c;  
         caps->caches[1].max_cell_size = 0x400;  
         caps->caches[2].entries = 0x106;  
         caps->caches[2].max_cell_size = 0x1000;  
 }  
286    
287  void rdp_make_control_caps(RDP_CONTROL_CAPS *caps)          out_uint16_le(s, 8);    /* Preferred BPP */
288  {          out_uint16_le(s, 1);    /* Receive 1 BPP */
289          caps->control_interest = 2;          out_uint16_le(s, 1);    /* Receive 4 BPP */
290          caps->detach_interest = 2;          out_uint16_le(s, 1);    /* Receive 8 BPP */
291            out_uint16_le(s, 800);  /* Desktop width */
292            out_uint16_le(s, 600);  /* Desktop height */
293            out_uint16(s, 0);       /* Pad */
294            out_uint16(s, 0);       /* Allow resize */
295            out_uint16_le(s, bitmap_compression ? 1 : 0);   /* Support compression */
296            out_uint16(s, 0);       /* Unknown */
297            out_uint16_le(s, 1);    /* Unknown */
298            out_uint16(s, 0);       /* Pad */
299  }  }
300    
301  void rdp_make_activate_caps(RDP_ACTIVATE_CAPS *caps)  /* Output order capability set */
302    static void
303    rdp_out_order_caps(STREAM s)
304  {  {
305  }          uint8 order_caps[32];
306    
 void rdp_make_pointer_caps(RDP_POINTER_CAPS *caps)  
 {  
         caps->colour_pointer = 0;  
         caps->cache_size = 20;  
 }  
307    
308  void rdp_make_share_caps(RDP_SHARE_CAPS *caps, uint16 userid)          memset(order_caps, 0, 32);
309  {          order_caps[0] = 1;      /* dest blt */
310  }          order_caps[1] = 1;      /* pat blt */
311            order_caps[2] = 1;      /* screen blt */
312            order_caps[3] = 1;      /* required for memblt? */
313            order_caps[8] = 1;      /* line */
314            order_caps[9] = 1;      /* line */
315            order_caps[10] = 1;     /* rect */
316            order_caps[11] = (desktop_save == False ? 0 : 1);       /* desksave */
317            order_caps[13] = 1;     /* memblt */
318            order_caps[14] = 1;     /* triblt */
319            order_caps[22] = 1;     /* polyline */
320            order_caps[27] = 1;     /* text2 */
321            out_uint16_le(s, RDP_CAPSET_ORDER);
322            out_uint16_le(s, RDP_CAPLEN_ORDER);
323    
324  void rdp_make_colcache_caps(RDP_COLCACHE_CAPS *caps)          out_uint8s(s, 20);      /* Terminal desc, pad */
325  {          out_uint16_le(s, 1);    /* Cache X granularity */
326          caps->cache_size = 6;          out_uint16_le(s, 20);   /* Cache Y granularity */
327            out_uint16(s, 0);       /* Pad */
328            out_uint16_le(s, 1);    /* Max order level */
329            out_uint16_le(s, 0x147);        /* Number of fonts */
330            out_uint16_le(s, 0x2a); /* Capability flags */
331            out_uint8p(s, order_caps, 32);  /* Orders supported */
332            out_uint16_le(s, 0x6a1);        /* Text capability flags */
333            out_uint8s(s, 6);       /* Pad */
334            out_uint32_le(s, desktop_save == False ? 0 : 0x38400);  /* Desktop cache size */
335            out_uint32(s, 0);       /* Unknown */
336            out_uint32_le(s, 0x4e4);        /* Unknown */
337  }  }
338    
339  void rdp_make_active_pdu(RDP_ACTIVE_PDU *pdu, uint32 shareid, uint16 userid)  /* Output bitmap cache capability set */
340    static void
341    rdp_out_bmpcache_caps(STREAM s)
342  {  {
343          memset(pdu, 0, sizeof(*pdu));          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
344          pdu->shareid = shareid;          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
         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;  
   
         rdp_make_general_caps (&pdu->general_caps );  
         rdp_make_bitmap_caps  (&pdu->bitmap_caps  );  
         rdp_make_order_caps   (&pdu->order_caps   );  
         rdp_make_bmpcache_caps(&pdu->bmpcache_caps);  
         rdp_make_control_caps (&pdu->control_caps );  
         rdp_make_activate_caps(&pdu->activate_caps);  
         rdp_make_pointer_caps (&pdu->pointer_caps );  
         rdp_make_share_caps   (&pdu->share_caps, userid);  
         rdp_make_colcache_caps(&pdu->colcache_caps);  
 }  
345    
346  void rdp_make_control_pdu(RDP_CONTROL_PDU *pdu, uint16 action)          out_uint8s(s, 24);      /* unused */
347  {          out_uint16_le(s, 0x258);        /* entries */
348          pdu->action = action;          out_uint16_le(s, 0x100);        /* max cell size */
349          pdu->userid = 0;          out_uint16_le(s, 0x12c);        /* entries */
350          pdu->controlid = 0;          out_uint16_le(s, 0x400);        /* max cell size */
351            out_uint16_le(s, 0x106);        /* entries */
352            out_uint16_le(s, 0x1000);       /* max cell size */
353  }  }
354    
355  void rdp_make_synchronize_pdu(RDP_SYNCHRONIZE_PDU *pdu, uint16 userid)  /* Output control capability set */
356    static void
357    rdp_out_control_caps(STREAM s)
358  {  {
359          pdu->type = 1;          out_uint16_le(s, RDP_CAPSET_CONTROL);
360          pdu->userid = userid;          out_uint16_le(s, RDP_CAPLEN_CONTROL);
 }  
361    
362  void rdp_make_font_pdu(RDP_FONT_PDU *pdu, uint16 seqno)          out_uint16(s, 0);       /* Control capabilities */
363  {          out_uint16(s, 0);       /* Remote detach */
364          pdu->num_fonts = 0;          out_uint16_le(s, 2);    /* Control interest */
365          pdu->unknown1 = 0x3e;          out_uint16_le(s, 2);    /* Detach interest */
         pdu->unknown2 = seqno;  
         pdu->entry_size = RDP_FONT_INFO_SIZE;  
366  }  }
367    
368  void rdp_make_input_pdu(RDP_INPUT_PDU *pdu)  /* Output activation capability set */
369    static void
370    rdp_out_activate_caps(STREAM s)
371  {  {
372          uint32 now = time(NULL);          out_uint16_le(s, RDP_CAPSET_ACTIVATE);
373            out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
         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;  
374    
375          pdu->event[1].event_time = now;          out_uint16(s, 0);       /* Help key */
376          pdu->event[1].message_type = RDP_INPUT_UNKNOWN;          out_uint16(s, 0);       /* Help index key */
377          pdu->event[1].device_flags = 0x8000;          out_uint16(s, 0);       /* Extended help key */
378          pdu->event[1].mouse_x = 15;          out_uint16(s, 0);       /* Window activate */
         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;  
379  }  }
380    
381  BOOL rdp_io_header(STREAM s, RDP_HEADER *hdr)  /* Output pointer capability set */
382    static void
383    rdp_out_pointer_caps(STREAM s)
384  {  {
385          BOOL res = True;          out_uint16_le(s, RDP_CAPSET_POINTER);
386            out_uint16_le(s, RDP_CAPLEN_POINTER);
         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;  
387    
388          return res;          out_uint16(s, 0);       /* Colour pointer */
389            out_uint16_le(s, 20);   /* Cache size */
390  }  }
391    
392  BOOL rdp_io_data_header(STREAM s, RDP_DATA_HEADER *hdr)  /* Output share capability set */
393    static void
394    rdp_out_share_caps(STREAM s)
395  {  {
396          BOOL res = True;          out_uint16_le(s, RDP_CAPSET_SHARE);
397            out_uint16_le(s, RDP_CAPLEN_SHARE);
         res = res ? lsb_io_uint32(s, &hdr->shareid      ) : False;  
         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;  
398    
399          return res;          out_uint16(s, 0);       /* userid */
400            out_uint16(s, 0);       /* pad */
401  }  }
402    
403  BOOL rdp_io_coord(STREAM s, uint16 *coord, BOOL delta)  /* Output colour cache capability set */
404    static void
405    rdp_out_colcache_caps(STREAM s)
406  {  {
407          uint8 change;          out_uint16_le(s, RDP_CAPSET_COLCACHE);
408          BOOL res;          out_uint16_le(s, RDP_CAPLEN_COLCACHE);
   
         if (delta)  
         {  
                 res = prs_io_uint8(s, &change);  
                 *coord += change;  
         }  
         else  
         {  
                 res = lsb_io_uint16(s, coord);  
         }  
409    
410          return res;          out_uint16_le(s, 6);    /* cache size */
411            out_uint16(s, 0);       /* pad */
412  }  }
413    
414  BOOL rdp_io_colormap(STREAM s, COLORMAP *colors)  static uint8 canned_caps[] = {
415  {          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
416          int datasize;          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
417            0x00, 0x00, 0x00, 0x00, 0x00,
418          lsb_io_uint16(s, &colors->ncolors);          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419          datasize = colors->ncolors * 3;          0x00, 0x00, 0x00, 0x00, 0x00,
420            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
421          if (datasize > sizeof(colors->colors))          0x00, 0x00, 0x00, 0x00, 0x00,
422                  return False;          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
423            0x00, 0x00, 0x00, 0x00, 0x00,
424          memcpy(colors->colors, s->data + s->offset, datasize);          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
425          s->offset += datasize;          0x0C, 0x00, 0x08, 0x00, 0x01,
426          return True;          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
427  }          0x10, 0x00, 0x34, 0x00, 0xFE,
428            0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
429            0xFE, 0x00, 0x08, 0x00, 0xFE,
430            0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
431            0xFE, 0x00, 0x80, 0x00, 0xFE,
432            0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
433            0x02, 0x00, 0x00, 0x00
434    };
435    
436  BOOL rdp_io_general_caps(STREAM s, RDP_GENERAL_CAPS *caps)  /* Output unknown capability set */
437    static void
438    rdp_out_unknown_caps(STREAM s)
439    {
440            out_uint16_le(s, RDP_CAPSET_UNKNOWN);
441            out_uint16_le(s, 0x58);
442    
443            out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);
444    }
445    
446    /* Send a confirm active PDU */
447    static void
448    rdp_send_confirm_active(void)
449    {
450            STREAM s;
451            uint16 caplen =
452                    RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
453                    RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
454                    RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
455                    RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
456    
457            s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));
458    
459            out_uint32_le(s, rdp_shareid);
460            out_uint16_le(s, 0x3ea);        /* userid */
461            out_uint16_le(s, sizeof(RDP_SOURCE));
462            out_uint16_le(s, caplen);
463    
464            out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));
465            out_uint16_le(s, 0xd);  /* num_caps */
466            out_uint8s(s, 2);       /* pad */
467    
468            rdp_out_general_caps(s);
469            rdp_out_bitmap_caps(s);
470            rdp_out_order_caps(s);
471            rdp_out_bmpcache_caps(s);
472            rdp_out_colcache_caps(s);
473            rdp_out_activate_caps(s);
474            rdp_out_control_caps(s);
475            rdp_out_pointer_caps(s);
476            rdp_out_share_caps(s);
477            rdp_out_unknown_caps(s);
478    
479            s_mark_end(s);
480            rdp_send(s, RDP_PDU_CONFIRM_ACTIVE);
481    }
482    
483    /* Respond to a demand active PDU */
484    static void
485    process_demand_active(STREAM s)
486  {  {
487          uint16 length = RDP_CAPLEN_GENERAL;          uint8 type;
         uint16 pkt_length = length;  
         BOOL res;  
488    
489          res = lsb_io_uint16(s, &pkt_length);          in_uint32_le(s, rdp_shareid);
         if (pkt_length != length)  
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
         }  
490    
491          res = res ? lsb_io_uint16(s, &caps->os_major_type ) : False;          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));
         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;  
492    
493          res = lsb_io_uint16(s, &pkt_length);          rdp_send_confirm_active();
494          if (pkt_length != length)          rdp_send_synchronise();
495          {          rdp_send_control(RDP_CTL_COOPERATE);
496                  fprintf(stderr, "Unrecognised capabilities size\n");          rdp_send_control(RDP_CTL_REQUEST_CONTROL);
497                  return False;          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
498          }          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
499            rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
500            rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);
501            rdp_send_fonts(1);
502            rdp_send_fonts(2);
503            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */
504            reset_order_state();
505    }
506    
507    /* Process a pointer PDU */
508    static void
509    process_pointer_pdu(STREAM s)
510    {
511            uint16 message_type;
512            uint16 x, y, width, height, cache_idx, masklen, datalen;
513            uint8 *mask, *data;
514            HCURSOR cursor;
515    
516          res = res ? lsb_io_uint16(s, &caps->preferred_bpp) : False;          in_uint16_le(s, message_type);
517          res = res ? lsb_io_uint16(s, &caps->receive1bpp  ) : False;          in_uint8s(s, 2);        /* pad */
         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;  
518    
519          res = lsb_io_uint16(s, &pkt_length);          switch (message_type)
         if (pkt_length != length)  
520          {          {
521                  fprintf(stderr, "Unrecognised capabilities size\n");                  case RDP_POINTER_MOVE:
522                  return False;                          in_uint16_le(s, x);
523          }                          in_uint16_le(s, y);
524                            if (s_check(s))
525          res = res ? prs_io_uint8s(s,  caps->terminal_desc, 16) : False;                                  ui_move_pointer(x, y);
526          res = res ? lsb_io_uint32(s, &caps->pad1             ) : False;                          break;
         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;  
 }  
527    
528  BOOL rdp_io_bmpcache_info(STREAM s, RDP_BMPCACHE_INFO *info)                  case RDP_POINTER_COLOR:
529  {                          in_uint16_le(s, cache_idx);
530          if (!lsb_io_uint16(s, &info->entries      ))                          in_uint16_le(s, x);
531                  return False;                          in_uint16_le(s, y);
532                            in_uint16_le(s, width);
533                            in_uint16_le(s, height);
534                            in_uint16_le(s, masklen);
535                            in_uint16_le(s, datalen);
536                            in_uint8p(s, data, datalen);
537                            in_uint8p(s, mask, masklen);
538                            cursor = ui_create_cursor(x, y, width, height, mask, data);
539                            ui_set_cursor(cursor);
540                            cache_put_cursor(cache_idx, cursor);
541                            break;
542    
543          if (!lsb_io_uint16(s, &info->max_cell_size))                  case RDP_POINTER_CACHED:
544                  return False;                          in_uint16_le(s, cache_idx);
545                            ui_set_cursor(cache_get_cursor(cache_idx));
546                            break;
547    
548          return True;                  default:
549                            DEBUG(("Pointer message 0x%x\n", message_type));
550            }
551  }  }
552    
553  BOOL rdp_io_bmpcache_caps(STREAM s, RDP_BMPCACHE_CAPS *caps)  /* Process bitmap updates */
554    static void
555    process_bitmap_updates(STREAM s)
556  {  {
557          uint16 length = RDP_CAPLEN_BMPCACHE;          uint16 num_updates;
558          uint16 pkt_length = length;          uint16 left, top, right, bottom, width, height;
559          BOOL res;          uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
560            uint8 *data, *bmpdata;
561          int i;          int i;
562    
563          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;  
564    
565          return res;          for (i = 0; i < num_updates; i++)
 }  
   
 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)  
566          {          {
567                  fprintf(stderr, "Unrecognised capabilities size\n");                  in_uint16_le(s, left);
568                  return False;                  in_uint16_le(s, top);
569          }                  in_uint16_le(s, right);
570                    in_uint16_le(s, bottom);
571                    in_uint16_le(s, width);
572                    in_uint16_le(s, height);
573                    in_uint16_le(s, bpp);
574                    Bpp = (bpp + 7) / 8;
575                    in_uint16_le(s, compress);
576                    in_uint16_le(s, bufsize);
577    
578          res = res ? lsb_io_uint16(s, &caps->control_caps    ) : False;                  cx = right - left + 1;
579          res = res ? lsb_io_uint16(s, &caps->remote_detach   ) : False;                  cy = bottom - top + 1;
         res = res ? lsb_io_uint16(s, &caps->control_interest) : False;  
         res = res ? lsb_io_uint16(s, &caps->detach_interest ) : False;  
580    
581          return res;                  DEBUG(("UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,cmp=%d)\n",
582  }                         left, top, right, bottom, width, height, compress));
583    
584  BOOL rdp_io_activate_caps(STREAM s, RDP_ACTIVATE_CAPS *caps)                  if (!compress)
585  {                  {
586          uint16 length = RDP_CAPLEN_ACTIVATE;                          int y;
587          uint16 pkt_length = length;                          bmpdata = xmalloc(width * height * Bpp);
588          BOOL res;                          for (y = 0; y < height; y++)
589                            {
590                                    in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
591                                              width * Bpp);
592                            }
593                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
594                            xfree(bmpdata);
595                            continue;
596                    }
597    
598          res = lsb_io_uint16(s, &pkt_length);                  in_uint8s(s, 2);        /* pad */
599          if (pkt_length != length)                  in_uint16_le(s, size);
600          {                  in_uint8s(s, 4);        /* line_size, final_size */
601                  fprintf(stderr, "Unrecognised capabilities size\n");                  in_uint8p(s, data, size);
602                  return False;                  bmpdata = xmalloc(width * height * Bpp);
603                    if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
604                    {
605                            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
606                    }
607                    xfree(bmpdata);
608          }          }
   
         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;  
609  }  }
610    
611  BOOL rdp_io_pointer_caps(STREAM s, RDP_POINTER_CAPS *caps)  /* Process a palette update */
612    static void
613    process_palette(STREAM s)
614  {  {
615          uint16 length = RDP_CAPLEN_POINTER;          COLOURENTRY *entry;
616          uint16 pkt_length = length;          COLOURMAP map;
617          BOOL res;          HCOLOURMAP hmap;
618            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->colour_pointer) : False;  
         res = res ? lsb_io_uint16(s, &caps->cache_size    ) : False;  
619    
620          return res;          in_uint8s(s, 2);        /* pad */
621  }          in_uint16_le(s, map.ncolours);
622            in_uint8s(s, 2);        /* pad */
623    
624  BOOL rdp_io_share_caps(STREAM s, RDP_SHARE_CAPS *caps)          map.colours = xmalloc(3 * map.ncolours);
 {  
         uint16 length = RDP_CAPLEN_SHARE;  
         uint16 pkt_length = length;  
         BOOL res;  
625    
626          res = lsb_io_uint16(s, &pkt_length);          for (i = 0; i < map.ncolours; i++)
         if (pkt_length != length)  
627          {          {
628                  fprintf(stderr, "Unrecognised capabilities size\n");                  entry = &map.colours[i];
629                  return False;                  in_uint8(s, entry->red);
630                    in_uint8(s, entry->green);
631                    in_uint8(s, entry->blue);
632          }          }
633    
634          res = res ? lsb_io_uint16(s, &caps->userid) : False;          hmap = ui_create_colourmap(&map);
635          res = res ? lsb_io_uint16(s, &caps->pad   ) : False;          ui_set_colourmap(hmap);
636    
637          return res;          xfree(map.colours);
638  }  }
639    
640  BOOL rdp_io_colcache_caps(STREAM s, RDP_COLCACHE_CAPS *caps)  /* Process an update PDU */
641    static void
642    process_update_pdu(STREAM s)
643  {  {
644          uint16 length = RDP_CAPLEN_COLCACHE;          uint16 update_type;
         uint16 pkt_length = length;  
         BOOL res;  
645    
646          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;  
         }  
647    
648          res = res ? lsb_io_uint16(s, &caps->cache_size) : False;          switch (update_type)
649          res = res ? lsb_io_uint16(s, &caps->pad       ) : False;          {
650                    case RDP_UPDATE_ORDERS:
651                            process_orders(s);
652                            break;
653    
654          return res;                  case RDP_UPDATE_BITMAP:
655  }                          process_bitmap_updates(s);
656                            break;
657    
658  uint8 canned_caps[] = {                  case RDP_UPDATE_PALETTE:
659  0x01,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x04,                          process_palette(s);
660  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  
 };  
661    
662  BOOL rdp_io_unknown_caps(STREAM s, void *caps)                  case RDP_UPDATE_SYNCHRONIZE:
663  {                          break;
         uint16 length = 0x58;  
         uint16 pkt_length = length;  
         BOOL res;  
664    
665          res = lsb_io_uint16(s, &pkt_length);                  default:
666          if (pkt_length != length)                          unimpl("update %d\n", update_type);
         {  
                 fprintf(stderr, "Unrecognised capabilities size\n");  
                 return False;  
667          }          }
668    
         res = res ? prs_io_uint8s(s, canned_caps, RDP_CAPLEN_UNKNOWN-4) : False;  
   
         return res;  
669  }  }
670    
671  BOOL rdp_io_active_pdu(STREAM s, RDP_ACTIVE_PDU *pdu, int pdutype)  /* Process data PDU */
672    static void
673    process_data_pdu(STREAM s)
674  {  {
675          uint16 capset;          uint8 data_pdu_type;
         uint16 length;  
         BOOL res;  
         int i;  
   
         res = lsb_io_uint32(s, &pdu->shareid);  
676    
677          if (pdutype == RDP_PDU_CONFIRM_ACTIVE)          in_uint8s(s, 8);        /* shareid, pad, streamid, length */
678                  res = res ? lsb_io_uint16(s, &pdu->userid    ) : False;          in_uint8(s, data_pdu_type);
679            in_uint8s(s, 3);        /* compress_type, compress_len */
680    
681          res = res ? lsb_io_uint16(s, &pdu->source_len) : False;          switch (data_pdu_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;  
         }  
   
         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  
682          {          {
683                  for (i = 0; i < pdu->num_caps; i++)                  case RDP_DATA_PDU_UPDATE:
684                  {                          process_update_pdu(s);
685                          if (!res)                          break;
                                 return False;  
686    
687                          if (!lsb_io_uint16(s, &capset))                  case RDP_DATA_PDU_POINTER:
688                                  return False;                          process_pointer_pdu(s);
689                            break;
690    
691                          switch (capset)                  case RDP_DATA_PDU_BELL:
692                          {                          ui_bell();
693                          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);  
694    
695                                  if (!lsb_io_uint16(s, &length))                  case RDP_DATA_PDU_LOGON:
696                                          return False;                          /* User logged on */
697                            break;
698    
699                                  s->offset += (length - 4);                  default:
700                          }                          unimpl("data PDU %d\n", data_pdu_type);
                 }  
701          }          }
   
         return res;  
702  }  }
703    
704  BOOL rdp_io_control_pdu(STREAM s, RDP_CONTROL_PDU *pdu)  /* Process incoming packets */
705    void
706    rdp_main_loop(void)
707  {  {
708          BOOL res = True;          uint8 type;
709            STREAM s;
         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;  
710    
711          switch (evt->message_type)          while ((s = rdp_recv(&type)) != NULL)
712          {          {
713          case RDP_INPUT_CODEPOINT:                  switch (type)
714          case RDP_INPUT_VIRTKEY:                  {
715                  res = res ? lsb_io_uint16(s, &evt->device_flags) : False;                          case RDP_PDU_DEMAND_ACTIVE:
716                  res = res ? lsb_io_uint16(s, &evt->kbd_keycode ) : False;                                  process_demand_active(s);
717                  break;                                  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;  
 }  
718    
719  BOOL rdp_io_input_pdu(STREAM s, RDP_INPUT_PDU *pdu)                          case RDP_PDU_DEACTIVATE:
720  {                                  break;
         BOOL res = True;  
         int i;  
721    
722          res = res ? lsb_io_uint16(s, &pdu->num_events) : False;                          case RDP_PDU_DATA:
723          res = res ? lsb_io_uint16(s, &pdu->pad       ) : False;                                  process_data_pdu(s);
724                                    break;
725    
726          if (pdu->num_events > RDP_MAX_EVENTS)                          case 0:
727          {                                  break;
                 fprintf(stderr, "Too many events in one PDU\n");  
                 return False;  
         }  
728    
729          for (i = 0; i < pdu->num_events; i++)                          default:
730          {                                  unimpl("PDU %d\n", type);
731                  res = res ? rdp_io_input_event(s, &pdu->event[i]) : False;                  }
732          }          }
   
         return res;  
733  }  }
734    
735  BOOL rdp_io_font_info(STREAM s, RDP_FONT_INFO *font)  /* Establish a connection up to the RDP layer */
736  {  BOOL
737          BOOL res = True;  rdp_connect(char *server, uint32 flags, char *domain, char *password,
738                char *command, char *directory)
         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)  
739  {  {
740          BOOL res = True;          if (!sec_connect(server))
         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");  
741                  return False;                  return False;
         }  
742    
743          for (i = 0; i < pdu->num_fonts; i++)          rdp_send_logon_info(flags, domain, username, password, command, directory);
744          {          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;  
745  }  }
746    
747  BOOL rdp_io_pointer(STREAM s, RDP_POINTER *ptr)  /* Disconnect from the RDP layer */
748    void
749    rdp_disconnect(void)
750  {  {
751          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;  
752  }  }
Legend:
Removed from v.7  
changed lines
  Added in v.340
  ViewVC Help
Powered by ViewVC 1.1.26