/[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 677 by n-ki, Mon Apr 26 13:48:39 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    
37  uint8 *g_next_packet;  uint8 *g_next_packet;
38  uint32 g_rdp_shareid;  uint32 g_rdp_shareid;
# Line 368  rdp_send_fonts(uint16 seq) Line 370  rdp_send_fonts(uint16 seq)
370          s = rdp_init_data(8);          s = rdp_init_data(8);
371    
372          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
373          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
374          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
375          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
376    
# Line 416  rdp_out_bitmap_caps(STREAM s) Line 418  rdp_out_bitmap_caps(STREAM s)
418          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
419          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
420          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
421          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
422          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
423          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
424          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
# Line 613  rdp_send_confirm_active(void) Line 615  rdp_send_confirm_active(void)
615          sec_send(s, sec_flags);          sec_send(s, sec_flags);
616  }  }
617    
618    /* Process a general capability set */
619    static void
620    rdp_process_general_caps(STREAM s)
621    {
622            uint16 pad2octetsB;     /* rdp5 flags? */
623    
624            in_uint8s(s, 10);
625            in_uint16_le(s, pad2octetsB);
626    
627            if (!pad2octetsB)
628                    g_use_rdp5 = False;
629    }
630    
631    /* Process a bitmap capability set */
632    static void
633    rdp_process_bitmap_caps(STREAM s)
634    {
635            uint16 width, height, bpp;
636    
637            in_uint16_le(s, bpp);
638            in_uint8s(s, 6);
639    
640            in_uint16_le(s, width);
641            in_uint16_le(s, height);
642    
643            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
644    
645            /*
646             * The server may limit bpp and change the size of the desktop (for
647             * example when shadowing another session).
648             */
649            g_server_bpp = bpp;
650            g_width = width;
651            g_height = height;
652    
653            ui_resize_window();
654    }
655    
656  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
657  static void  static void
658  process_demand_active(STREAM s)  process_demand_active(STREAM s)
659  {  {
660          uint8 type;          int n;
661          uint16 i;          uint8 type, *next;
662          uint16 p_bpp;          uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;
663    
664          in_uint32_le(s, g_rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
665            in_uint16_le(s, len_src_descriptor);
666            in_uint16_le(s, len_combined_caps);
667            in_uint8s(s, len_src_descriptor);
668    
669            in_uint16_le(s, num_capsets);
670            in_uint8s(s, 2);        /* pad */
671    
672            DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));
673    
674          /* scan for prefered bpp */          for (n = 0; n < num_capsets; n++)
         while (s_check_rem(s, 6))  
675          {          {
676                  in_uint16_le(s, i);                  in_uint16_le(s, capset_type);
677                  if (i == RDP_CAPSET_BITMAP)                  in_uint16_le(s, capset_length);
678    
679                    next = s->p + capset_length - 4;
680    
681                    switch (capset_type)
682                  {                  {
683                          in_uint16_le(s, i);                          case RDP_CAPSET_GENERAL:
684                          if (i == RDP_CAPLEN_BITMAP)                                  rdp_process_general_caps(s);
685                          {                                  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;  
                                 }  
                         }  
                 }  
         }  
686    
687                            case RDP_CAPSET_BITMAP:
688                                    rdp_process_bitmap_caps(s);
689                                    break;
690                    }
691    
692          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));                  s->p = next;
693            }
694    
695          rdp_send_confirm_active();          rdp_send_confirm_active();
696          rdp_send_synchronise();          rdp_send_synchronise();
# Line 658  process_demand_active(STREAM s) Line 700  process_demand_active(STREAM s)
700          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
701          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
702          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);
703          rdp_send_fonts(1);  
704          rdp_send_fonts(2);          if (g_use_rdp5)
705          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */          {
706                    rdp_send_fonts(3);
707            }
708            else
709            {
710                    rdp_send_fonts(1);
711                    rdp_send_fonts(2);
712            }
713    
714            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
715          reset_order_state();          reset_order_state();
716  }  }
717    
# Line 886  process_update_pdu(STREAM s) Line 937  process_update_pdu(STREAM s)
937    
938  }  }
939    
940    /* Process a disconnect PDU */
941    void
942    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
943    {
944            in_uint32_le(s, *ext_disc_reason);
945    
946            DEBUG(("Received disconnect PDU\n"));
947    }
948    
949  /* Process data PDU */  /* Process data PDU */
950  static void  static BOOL
951  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
952  {  {
953          uint8 data_pdu_type;          uint8 data_pdu_type;
954          uint8 ctype;          uint8 ctype;
955          uint16 clen;          uint16 clen;
956          int roff, rlen, len, ret;          int len;
957    #if 0
958            int roff, rlen, ret;
959          static struct stream ns;          static struct stream ns;
960          static signed char *dict = 0;          static signed char *dict = 0;
961    #endif
962    
963          in_uint8s(s, 6);        /* shareid, pad, streamid */          in_uint8s(s, 6);        /* shareid, pad, streamid */
964          in_uint16(s, len);          in_uint16(s, len);
# Line 936  process_data_pdu(STREAM s) Line 999  process_data_pdu(STREAM s)
999                          process_update_pdu(s);                          process_update_pdu(s);
1000                          break;                          break;
1001    
1002                    case RDP_DATA_PDU_CONTROL:
1003                            DEBUG(("Received Control PDU\n"));
1004                            break;
1005    
1006                    case RDP_DATA_PDU_SYNCHRONISE:
1007                            DEBUG(("Received Sync PDU\n"));
1008                            break;
1009    
1010                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1011                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1012                          break;                          break;
# Line 950  process_data_pdu(STREAM s) Line 1021  process_data_pdu(STREAM s)
1021                          break;                          break;
1022    
1023                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
1024                          /* Normally received when user logs out or disconnects from a                          process_disconnect_pdu(s, ext_disc_reason);
1025                             console session on Windows XP and 2003 Server */                          return True;
                         DEBUG(("Received disconnect PDU\n"));  
                         break;  
1026    
1027                  default:                  default:
1028                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1029          }          }
1030            return False;
1031  }  }
1032    
1033  /* Process incoming packets */  /* Process incoming packets */
1034  BOOL  void
1035  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1036  {  {
1037          uint8 type;          uint8 type;
1038            BOOL disc = False;      /* True when a disconnect PDU was received */
1039          STREAM s;          STREAM s;
1040    
1041          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 973  rdp_main_loop(void) Line 1044  rdp_main_loop(void)
1044                  {                  {
1045                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1046                                  process_demand_active(s);                                  process_demand_active(s);
1047                                    *deactivated = False;
1048                                  break;                                  break;
1049    
1050                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1051                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1052                                  /* 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; */  
1053                                  break;                                  break;
1054    
1055                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1056                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1057                                  break;                                  break;
1058    
1059                          case 0:                          case 0:
# Line 995  rdp_main_loop(void) Line 1062  rdp_main_loop(void)
1062                          default:                          default:
1063                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1064                  }                  }
1065    
1066                    if (disc)
1067                    {
1068                            return;
1069                    }
1070          }          }
1071          return True;          return;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1072  }  }
1073    
1074  /* 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.677
  ViewVC Help
Powered by ViewVC 1.1.26