/[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 658 by astrand, Fri Apr 16 11:36:29 2004 UTC revision 687 by n-ki, Fri Apr 30 06:18:08 2004 UTC
# Line 31  extern BOOL g_use_rdp5; Line 31  extern BOOL g_use_rdp5;
31  extern uint16 g_server_rdp_version;  extern uint16 g_server_rdp_version;
32  extern uint32 g_rdp5_performanceflags;  extern uint32 g_rdp5_performanceflags;
33  extern int g_server_bpp;  extern int g_server_bpp;
34    extern int g_width;
35    extern int g_height;
36    extern BOOL g_bitmap_cache;
37    
38  uint8 *g_next_packet;  uint8 *g_next_packet;
39  uint32 g_rdp_shareid;  uint32 g_rdp_shareid;
40    
41    extern RDPCOMP g_mppc_dict;
42    
43  #if WITH_DEBUG  #if WITH_DEBUG
44  static uint32 g_packetno;  static uint32 g_packetno;
45  #endif  #endif
# Line 172  rdp_send_logon_info(uint32 flags, char * Line 177  rdp_send_logon_info(uint32 flags, char *
177          time_t tzone;          time_t tzone;
178    
179  #if 0  #if 0
180          // enable rdp compression          /* enable rdp compression */
181            /* some problems still exist with rdp5 */
182          flags |= RDP_COMPRESSION;          flags |= RDP_COMPRESSION;
183  #endif  #endif
184    
# Line 198  rdp_send_logon_info(uint32 flags, char * Line 204  rdp_send_logon_info(uint32 flags, char *
204          }          }
205          else          else
206          {          {
207    
208                  flags |= RDP_LOGON_BLOB;                  flags |= RDP_LOGON_BLOB;
209                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
210                  packetlen = 4 + /* Unknown uint32 */                  packetlen = 4 + /* Unknown uint32 */
# Line 368  rdp_send_fonts(uint16 seq) Line 375  rdp_send_fonts(uint16 seq)
375          s = rdp_init_data(8);          s = rdp_init_data(8);
376    
377          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
378          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
379          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
380          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
381    
# Line 416  rdp_out_bitmap_caps(STREAM s) Line 423  rdp_out_bitmap_caps(STREAM s)
423          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
424          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
425          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
426          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
427          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
428          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
429          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
# Line 434  rdp_out_order_caps(STREAM s) Line 441  rdp_out_order_caps(STREAM s)
441          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
442          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
443          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
444          order_caps[3] = 1;      /* required for memblt? */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
445          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
446          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
447          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
# Line 613  rdp_send_confirm_active(void) Line 620  rdp_send_confirm_active(void)
620          sec_send(s, sec_flags);          sec_send(s, sec_flags);
621  }  }
622    
623    /* Process a general capability set */
624    static void
625    rdp_process_general_caps(STREAM s)
626    {
627            uint16 pad2octetsB;     /* rdp5 flags? */
628    
629            in_uint8s(s, 10);
630            in_uint16_le(s, pad2octetsB);
631    
632            if (!pad2octetsB)
633                    g_use_rdp5 = False;
634    }
635    
636    /* Process a bitmap capability set */
637    static void
638    rdp_process_bitmap_caps(STREAM s)
639    {
640            uint16 width, height, bpp;
641    
642            in_uint16_le(s, bpp);
643            in_uint8s(s, 6);
644    
645            in_uint16_le(s, width);
646            in_uint16_le(s, height);
647    
648            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
649    
650            /*
651             * The server may limit bpp and change the size of the desktop (for
652             * example when shadowing another session).
653             */
654            g_server_bpp = bpp;
655            g_width = width;
656            g_height = height;
657    
658            ui_resize_window();
659    }
660    
661  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
662  static void  static void
663  process_demand_active(STREAM s)  process_demand_active(STREAM s)
664  {  {
665          uint8 type;          int n;
666          uint16 i;          uint8 type, *next;
667          uint16 p_bpp;          uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;
668    
669          in_uint32_le(s, g_rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
670            in_uint16_le(s, len_src_descriptor);
671            in_uint16_le(s, len_combined_caps);
672            in_uint8s(s, len_src_descriptor);
673    
674          /* scan for prefered bpp */          in_uint16_le(s, num_capsets);
675          while (s_check_rem(s, 6))          in_uint8s(s, 2);        /* pad */
676    
677            DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));
678    
679            for (n = 0; n < num_capsets; n++)
680          {          {
681                  in_uint16_le(s, i);                  in_uint16_le(s, capset_type);
682                  if (i == RDP_CAPSET_BITMAP)                  in_uint16_le(s, capset_length);
683    
684                    next = s->p + capset_length - 4;
685    
686                    switch (capset_type)
687                  {                  {
688                          in_uint16_le(s, i);                          case RDP_CAPSET_GENERAL:
689                          if (i == RDP_CAPLEN_BITMAP)                                  rdp_process_general_caps(s);
690                          {                                  break;
                                 in_uint16_le(s, p_bpp);  
                                 if (p_bpp == 8 || p_bpp == 15 || p_bpp == 16 || p_bpp == 24)  
                                 {  
                                         if (p_bpp < g_server_bpp)  
                                         {  
                                                 warning("Server limited colour depth to %d bits\n",  
                                                         p_bpp);  
                                                 g_server_bpp = p_bpp;  
                                         }  
                                         break;  
                                 }  
                         }  
                 }  
         }  
691    
692                            case RDP_CAPSET_BITMAP:
693                                    rdp_process_bitmap_caps(s);
694                                    break;
695                    }
696    
697          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));                  s->p = next;
698            }
699    
700          rdp_send_confirm_active();          rdp_send_confirm_active();
701          rdp_send_synchronise();          rdp_send_synchronise();
# Line 658  process_demand_active(STREAM s) Line 705  process_demand_active(STREAM s)
705          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
706          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
707          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);
708          rdp_send_fonts(1);  
709          rdp_send_fonts(2);          if (g_use_rdp5)
710          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */          {
711                    rdp_send_fonts(3);
712            }
713            else
714            {
715                    rdp_send_fonts(1);
716                    rdp_send_fonts(2);
717            }
718    
719            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
720          reset_order_state();          reset_order_state();
721  }  }
722    
# Line 886  process_update_pdu(STREAM s) Line 942  process_update_pdu(STREAM s)
942    
943  }  }
944    
945    /* Process a disconnect PDU */
946    void
947    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
948    {
949            in_uint32_le(s, *ext_disc_reason);
950    
951            DEBUG(("Received disconnect PDU\n"));
952    }
953    
954  /* Process data PDU */  /* Process data PDU */
955  static void  static BOOL
956  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
957  {  {
958          uint8 data_pdu_type;          uint8 data_pdu_type;
959          uint8 ctype;          uint8 ctype;
960          uint16 clen;          uint16 clen;
961          int roff, rlen, len, ret;          uint32 len;
962          static struct stream ns;  
963          static signed char *dict = 0;          uint32 roff, rlen;
964    
965            struct stream *ns = &(g_mppc_dict.ns);
966    
967          in_uint8s(s, 6);        /* shareid, pad, streamid */          in_uint8s(s, 6);        /* shareid, pad, streamid */
968          in_uint16(s, len);          in_uint16(s, len);
# Line 904  process_data_pdu(STREAM s) Line 971  process_data_pdu(STREAM s)
971          in_uint16(s, clen);          in_uint16(s, clen);
972          clen -= 18;          clen -= 18;
973    
974  #if 0          if (ctype & RDP_MPPC_COMPRESSED)
         if (ctype & 0x20)  
975          {          {
                 if (!dict)  
                 {  
                         dict = (signed char *) malloc(8200 * sizeof(signed char));  
                         dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));  
                 }  
976    
977                  ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
978                            error("error while decompressing packet\n");
979    
980                  len -= 18;                  //len -= 18;
981    
982                  ns.data = xrealloc(ns.data, len);                  /* allocate memory and copy the uncompressed data into the temporary stream */
983                    ns->data = xrealloc(ns->data, rlen);
984    
985                  ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);                  memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
986    
987                  ns.size = len;                  ns->size = rlen;
988                  ns.end = ns.data + ns.size;                  ns->end = (ns->data + ns->size);
989                  ns.p = ns.data;                  ns->p = ns->data;
990                  ns.rdp_hdr = ns.p;                  ns->rdp_hdr = ns->p;
991    
992                  s = &ns;                  s = ns;
993          }          }
 #endif  
994    
995          switch (data_pdu_type)          switch (data_pdu_type)
996          {          {
# Line 936  process_data_pdu(STREAM s) Line 998  process_data_pdu(STREAM s)
998                          process_update_pdu(s);                          process_update_pdu(s);
999                          break;                          break;
1000    
1001                    case RDP_DATA_PDU_CONTROL:
1002                            DEBUG(("Received Control PDU\n"));
1003                            break;
1004    
1005                    case RDP_DATA_PDU_SYNCHRONISE:
1006                            DEBUG(("Received Sync PDU\n"));
1007                            break;
1008    
1009                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1010                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1011                          break;                          break;
# Line 950  process_data_pdu(STREAM s) Line 1020  process_data_pdu(STREAM s)
1020                          break;                          break;
1021    
1022                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
1023                          /* Normally received when user logs out or disconnects from a                          process_disconnect_pdu(s, ext_disc_reason);
1024                             console session on Windows XP and 2003 Server */                          return True;
                         DEBUG(("Received disconnect PDU\n"));  
                         break;  
1025    
1026                  default:                  default:
1027                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1028          }          }
1029            return False;
1030  }  }
1031    
1032  /* Process incoming packets */  /* Process incoming packets */
1033  BOOL  void
1034  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1035  {  {
1036          uint8 type;          uint8 type;
1037            BOOL disc = False;      /* True when a disconnect PDU was received */
1038          STREAM s;          STREAM s;
1039    
1040          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 973  rdp_main_loop(void) Line 1043  rdp_main_loop(void)
1043                  {                  {
1044                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1045                                  process_demand_active(s);                                  process_demand_active(s);
1046                                    *deactivated = False;
1047                                  break;                                  break;
1048    
1049                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1050                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1051                                  /* We thought we could detect a clean                                  *deactivated = True;
                                    shutdown of the session by this  
                                    packet, but it seems Windows 2003  
                                    is sending us one of these when we  
                                    reconnect to a disconnected session  
                                    return True; */  
1052                                  break;                                  break;
1053    
1054                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1055                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1056                                  break;                                  break;
1057    
1058                          case 0:                          case 0:
# Line 995  rdp_main_loop(void) Line 1061  rdp_main_loop(void)
1061                          default:                          default:
1062                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1063                  }                  }
1064    
1065                    if (disc)
1066                    {
1067                            return;
1068                    }
1069          }          }
1070          return True;          return;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1071  }  }
1072    
1073  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.658  
changed lines
  Added in v.687
  ViewVC Help
Powered by ViewVC 1.1.26