/[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 604 by stargo, Sat Feb 14 19:30:01 2004 UTC revision 676 by astrand, Tue Apr 20 07:01:21 2004 UTC
# Line 29  extern BOOL g_encryption; Line 29  extern BOOL g_encryption;
29  extern BOOL g_desktop_save;  extern BOOL g_desktop_save;
30  extern BOOL g_use_rdp5;  extern BOOL g_use_rdp5;
31  extern uint16 g_server_rdp_version;  extern uint16 g_server_rdp_version;
32    extern uint32 g_rdp5_performanceflags;
33  extern int g_server_bpp;  extern int g_server_bpp;
34    
35  uint8 *g_next_packet;  uint8 *g_next_packet;
# Line 156  static void Line 157  static void
157  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
158                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
159  {  {
160            char *ipaddr = tcp_get_address();
161          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
162          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
163          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
164          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
165          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
166          int len_ip = 2 * strlen("127.0.0.1");          int len_ip = 2 * strlen(ipaddr);
167          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
168          int packetlen = 0;          int packetlen = 0;
169          uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;          uint32 sec_flags = g_encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
# Line 169  rdp_send_logon_info(uint32 flags, char * Line 171  rdp_send_logon_info(uint32 flags, char *
171          time_t t = time(NULL);          time_t t = time(NULL);
172          time_t tzone;          time_t tzone;
173    
174    #if 0
175            // enable rdp compression
176            flags |= RDP_COMPRESSION;
177    #endif
178    
179          if (!g_use_rdp5 || 1 == g_server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
180          {          {
181                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
# Line 266  rdp_send_logon_info(uint32 flags, char * Line 273  rdp_send_logon_info(uint32 flags, char *
273                  }                  }
274                  out_uint16_le(s, 2);                  out_uint16_le(s, 2);
275                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
276                  rdp_out_unistr(s, "127.0.0.1", len_ip);                  rdp_out_unistr(s, ipaddr, len_ip);
277                  out_uint16_le(s, len_dll + 2);                  out_uint16_le(s, len_dll + 2);
278                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
279    
# Line 276  rdp_send_logon_info(uint32 flags, char * Line 283  rdp_send_logon_info(uint32 flags, char *
283                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
284                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
285    
   
286                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
287                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
288                  out_uint32_le(s, 3);                  out_uint32_le(s, 3);
# Line 292  rdp_send_logon_info(uint32 flags, char * Line 298  rdp_send_logon_info(uint32 flags, char *
298                  out_uint32(s, 0);                  out_uint32(s, 0);
299                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
300                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
301                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
302                  out_uint32(s, 0);                  out_uint32(s, 0);
303    
304    
# Line 403  rdp_out_bitmap_caps(STREAM s) Line 409  rdp_out_bitmap_caps(STREAM s)
409          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
410          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
411    
412          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
413          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
414          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
415          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
# Line 612  static void Line 618  static void
618  process_demand_active(STREAM s)  process_demand_active(STREAM s)
619  {  {
620          uint8 type;          uint8 type;
621            uint16 i;
622            uint16 p_bpp;
623    
624          in_uint32_le(s, g_rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
625    
626            /* scan for prefered bpp */
627            while (s_check_rem(s, 6))
628            {
629                    in_uint16_le(s, i);
630                    if (i == RDP_CAPSET_BITMAP)
631                    {
632                            in_uint16_le(s, i);
633                            if (i == RDP_CAPLEN_BITMAP)
634                            {
635                                    in_uint16_le(s, p_bpp);
636                                    if (p_bpp == 8 || p_bpp == 15 || p_bpp == 16 || p_bpp == 24)
637                                    {
638                                            if (p_bpp < g_server_bpp)
639                                            {
640                                                    warning("Server limited colour depth to %d bits\n",
641                                                            p_bpp);
642                                                    g_server_bpp = p_bpp;
643                                            }
644                                            break;
645                                    }
646                            }
647                    }
648            }
649    
650    
651          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
652    
653          rdp_send_confirm_active();          rdp_send_confirm_active();
# Line 748  process_bitmap_updates(STREAM s) Line 781  process_bitmap_updates(STREAM s)
781                  DEBUG(("BITMAP_UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,Bpp=%d,cmp=%d)\n",                  DEBUG(("BITMAP_UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,Bpp=%d,cmp=%d)\n",
782                         left, top, right, bottom, width, height, Bpp, compress));                         left, top, right, bottom, width, height, Bpp, compress));
783    
                 /* Server may limit bpp - this is how we find out */  
                 if (g_server_bpp != bpp)  
                 {  
                         warning("Server limited colour depth to %d bits\n", bpp);  
                         g_server_bpp = bpp;  
                 }  
   
784                  if (!compress)                  if (!compress)
785                  {                  {
786                          int y;                          int y;
# Line 860  process_update_pdu(STREAM s) Line 886  process_update_pdu(STREAM s)
886    
887  }  }
888    
889    /* Process a disconnect PDU */
890    void
891    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
892    {
893            in_uint32_le(s, *ext_disc_reason);
894    
895            DEBUG(("Received disconnect PDU\n"));
896    }
897    
898  /* Process data PDU */  /* Process data PDU */
899  static void  static BOOL
900  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
901  {  {
902          uint8 data_pdu_type;          uint8 data_pdu_type;
903            uint8 ctype;
904            uint16 clen;
905            int len;
906    #if 0
907            int roff, rlen, ret;
908            static struct stream ns;
909            static signed char *dict = 0;
910    #endif
911    
912          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          in_uint8s(s, 6);        /* shareid, pad, streamid */
913            in_uint16(s, len);
914          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
915          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
916            in_uint16(s, clen);
917            clen -= 18;
918    
919    #if 0
920            if (ctype & 0x20)
921            {
922                    if (!dict)
923                    {
924                            dict = (signed char *) malloc(8200 * sizeof(signed char));
925                            dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));
926                    }
927    
928                    ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);
929    
930                    len -= 18;
931    
932                    ns.data = xrealloc(ns.data, len);
933    
934                    ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);
935    
936                    ns.size = len;
937                    ns.end = ns.data + ns.size;
938                    ns.p = ns.data;
939                    ns.rdp_hdr = ns.p;
940    
941                    s = &ns;
942            }
943    #endif
944    
945          switch (data_pdu_type)          switch (data_pdu_type)
946          {          {
# Line 876  process_data_pdu(STREAM s) Line 948  process_data_pdu(STREAM s)
948                          process_update_pdu(s);                          process_update_pdu(s);
949                          break;                          break;
950    
951                    case RDP_DATA_PDU_CONTROL:
952                            DEBUG(("Received Control PDU\n"));
953                            break;
954    
955                    case RDP_DATA_PDU_SYNCHRONISE:
956                            DEBUG(("Received Sync PDU\n"));
957                            break;
958    
959                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
960                          process_pointer_pdu(s);                          process_pointer_pdu(s);
961                          break;                          break;
# Line 890  process_data_pdu(STREAM s) Line 970  process_data_pdu(STREAM s)
970                          break;                          break;
971    
972                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
973                          /* Normally received when user logs out or disconnects from a                          process_disconnect_pdu(s, ext_disc_reason);
974                             console session on Windows XP and 2003 Server */                          return True;
                         DEBUG(("Received disconnect PDU\n"));  
                         break;  
975    
976                  default:                  default:
977                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
978          }          }
979            return False;
980  }  }
981    
982  /* Process incoming packets */  /* Process incoming packets */
983  BOOL  void
984  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
985  {  {
986          uint8 type;          uint8 type;
987            BOOL disc = False;      /* True when a disconnect PDU was received */
988          STREAM s;          STREAM s;
989    
990          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 913  rdp_main_loop(void) Line 993  rdp_main_loop(void)
993                  {                  {
994                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
995                                  process_demand_active(s);                                  process_demand_active(s);
996                                    *deactivated = False;
997                                  break;                                  break;
998    
999                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1000                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  *deactivated = True;
                                 /* We thought we could detect a clean  
                                    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; */  
1001                                  break;                                  break;
1002    
1003                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1004                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1005                                  break;                                  break;
1006    
1007                          case 0:                          case 0:
# Line 935  rdp_main_loop(void) Line 1010  rdp_main_loop(void)
1010                          default:                          default:
1011                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1012                  }                  }
1013    
1014                    if (disc)
1015                    {
1016                            return;
1017                    }
1018          }          }
1019          return True;          return;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1020  }  }
1021    
1022  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.604  
changed lines
  Added in v.676
  ViewVC Help
Powered by ViewVC 1.1.26