/[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 738 by astrand, Mon Jul 12 21:07: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    extern BOOL g_bitmap_cache;
37    extern BOOL g_bitmap_cache_persist_enable;
38    
39  uint8 *g_next_packet;  uint8 *g_next_packet;
40  uint32 g_rdp_shareid;  uint32 g_rdp_shareid;
41    
42    extern RDPCOMP g_mppc_dict;
43    
44  #if WITH_DEBUG  #if WITH_DEBUG
45  static uint32 g_packetno;  static uint32 g_packetno;
46  #endif  #endif
# Line 45  rdp_recv(uint8 * type) Line 51  rdp_recv(uint8 * type)
51  {  {
52          static STREAM rdp_s;          static STREAM rdp_s;
53          uint16 length, pdu_type;          uint16 length, pdu_type;
54            uint8 rdpver;
55    
56          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))
57          {          {
58                  rdp_s = sec_recv();                  rdp_s = sec_recv(&rdpver);
59                  if (rdp_s == NULL)                  if (rdp_s == NULL)
60                          return NULL;                          return NULL;
61                    if (rdpver != 3)
62                    {
63                            /* rdp5_process should move g_next_packet ok */
64                            rdp5_process(rdp_s);
65                            *type = 0;
66                            return rdp_s;
67                    }
68    
69                  g_next_packet = rdp_s->p;                  g_next_packet = rdp_s->p;
70          }          }
# Line 172  rdp_send_logon_info(uint32 flags, char * Line 186  rdp_send_logon_info(uint32 flags, char *
186          time_t tzone;          time_t tzone;
187    
188  #if 0  #if 0
189          // enable rdp compression          /* enable rdp compression */
190            /* some problems still exist with rdp5 */
191          flags |= RDP_COMPRESSION;          flags |= RDP_COMPRESSION;
192  #endif  #endif
193    
# Line 198  rdp_send_logon_info(uint32 flags, char * Line 213  rdp_send_logon_info(uint32 flags, char *
213          }          }
214          else          else
215          {          {
216    
217                  flags |= RDP_LOGON_BLOB;                  flags |= RDP_LOGON_BLOB;
218                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
219                  packetlen = 4 + /* Unknown uint32 */                  packetlen = 4 + /* Unknown uint32 */
# Line 359  rdp_send_input(uint32 time, uint16 messa Line 375  rdp_send_input(uint32 time, uint16 messa
375          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
376  }  }
377    
378    /* Inform the server on the contents of the persistent bitmap cache */
379    static void
380    rdp_enum_bmpcache2(void)
381    {
382            STREAM s;
383            uint8 idlist[BMPCACHE2_NUM_PSTCELLS * sizeof(BITMAP_ID)];
384            uint32 nids, offset, count, flags;
385    
386            offset = 0;
387            nids = pstcache_enumerate(2, idlist);
388    
389            while (offset < nids)
390            {
391                    count = MIN(nids - offset, 169);
392    
393                    s = rdp_init_data(24 + count * sizeof(BITMAP_ID));
394    
395                    flags = 0;
396                    if (offset == 0)
397                            flags |= PDU_FLAG_FIRST;
398                    if (nids - offset <= 169)
399                            flags |= PDU_FLAG_LAST;
400    
401                    /* header */
402                    out_uint32_le(s, 0);
403                    out_uint16_le(s, count);
404                    out_uint16_le(s, 0);
405                    out_uint16_le(s, 0);
406                    out_uint16_le(s, 0);
407                    out_uint16_le(s, 0);
408                    out_uint16_le(s, nids);
409                    out_uint32_le(s, 0);
410                    out_uint32_le(s, flags);
411    
412                    /* list */
413                    out_uint8a(s, idlist + offset * sizeof(BITMAP_ID), count * sizeof(BITMAP_ID));
414    
415                    s_mark_end(s);
416                    rdp_send_data(s, 0x2b);
417    
418                    offset += 169;
419            }
420    }
421    
422  /* Send an (empty) font information PDU */  /* Send an (empty) font information PDU */
423  static void  static void
424  rdp_send_fonts(uint16 seq)  rdp_send_fonts(uint16 seq)
# Line 368  rdp_send_fonts(uint16 seq) Line 428  rdp_send_fonts(uint16 seq)
428          s = rdp_init_data(8);          s = rdp_init_data(8);
429    
430          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
431          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
432          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
433          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
434    
# Line 416  rdp_out_bitmap_caps(STREAM s) Line 476  rdp_out_bitmap_caps(STREAM s)
476          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
477          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
478          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
479          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
480          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
481          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
482          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
# Line 434  rdp_out_order_caps(STREAM s) Line 494  rdp_out_order_caps(STREAM s)
494          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
495          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
496          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
497          order_caps[3] = 1;      /* required for memblt? */          order_caps[3] = (g_bitmap_cache ? 1 : 0);       /* memblt */
498          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
499          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
500          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
# Line 479  rdp_out_bmpcache_caps(STREAM s) Line 539  rdp_out_bmpcache_caps(STREAM s)
539          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */          out_uint16_le(s, 0x1000 * Bpp); /* max cell size */
540  }  }
541    
542    /* Output bitmap cache v2 capability set */
543    static void
544    rdp_out_bmpcache2_caps(STREAM s)
545    {
546            out_uint16_le(s, RDP_CAPSET_BMPCACHE2);
547            out_uint16_le(s, RDP_CAPLEN_BMPCACHE2);
548    
549            out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
550    
551            out_uint16_le(s, 0x0300);       /* flags? number of caches? */
552    
553            out_uint32_le(s, BMPCACHE2_C0_CELLS);
554            out_uint32_le(s, BMPCACHE2_C1_CELLS);
555            if (pstcache_init(2))
556            {
557                    out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
558            }
559            else
560            {
561                    out_uint32_le(s, BMPCACHE2_C2_CELLS);
562            }
563            out_uint8s(s, 20);      /* other bitmap caches not used */
564    }
565    
566  /* Output control capability set */  /* Output control capability set */
567  static void  static void
568  rdp_out_control_caps(STREAM s)  rdp_out_control_caps(STREAM s)
# Line 538  rdp_out_colcache_caps(STREAM s) Line 622  rdp_out_colcache_caps(STREAM s)
622          out_uint16(s, 0);       /* pad */          out_uint16(s, 0);       /* pad */
623  }  }
624    
625  static uint8 canned_caps[] = {  static uint8 caps_0x0d[] = {
626          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,          0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
627          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,          0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
628          0x00, 0x00, 0x00, 0x00, 0x00,          0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
629          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
630          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
631          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
632          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
633          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
634          0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
635          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
636          0x0C, 0x00, 0x08, 0x00, 0x01,          0x00, 0x00, 0x00, 0x00
637          0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,  };
638          0x10, 0x00, 0x34, 0x00, 0xFE,  
639          0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,  static uint8 caps_0x0c[] = { 0x01, 0x00, 0x00, 0x00 };
640          0xFE, 0x00, 0x08, 0x00, 0xFE,  
641          0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,  static uint8 caps_0x0e[] = { 0x01, 0x00, 0x00, 0x00 };
642          0xFE, 0x00, 0x80, 0x00, 0xFE,  
643          0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,  static uint8 caps_0x10[] = {
644          0x02, 0x00, 0x00, 0x00          0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00,
645            0xFE, 0x00, 0x08, 0x00, 0xFE, 0x00, 0x08, 0x00,
646            0xFE, 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00,
647            0xFE, 0x00, 0x40, 0x00, 0xFE, 0x00, 0x80, 0x00,
648            0xFE, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08,
649            0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
650  };  };
651    
652  /* Output unknown capability sets (number 13, 12, 14 and 16) */  /* Output unknown capability sets */
653  static void  static void
654  rdp_out_unknown_caps(STREAM s)  rdp_out_unknown_caps(STREAM s, uint16 id, uint16 length, uint8 * caps)
655  {  {
656          out_uint16_le(s, RDP_CAPSET_UNKNOWN);          out_uint16_le(s, id);
657          out_uint16_le(s, 0x58);          out_uint16_le(s, length);
658    
659          out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);          out_uint8p(s, caps, length - 4);
660  }  }
661    
662  #define RDP5_FLAG 0x0030  #define RDP5_FLAG 0x0030
# Line 581  rdp_send_confirm_active(void) Line 670  rdp_send_confirm_active(void)
670                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +                  RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
671                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +                  RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
672                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +                  RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
673                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;                  RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE +
674                    0x58 + 0x08 + 0x08 + 0x34 /* unknown caps */  +
675                    4 /* w2k fix, why? */ ;
676    
677          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));          s = sec_init(sec_flags, 6 + 14 + caplen + sizeof(RDP_SOURCE));
678    
# Line 601  rdp_send_confirm_active(void) Line 692  rdp_send_confirm_active(void)
692          rdp_out_general_caps(s);          rdp_out_general_caps(s);
693          rdp_out_bitmap_caps(s);          rdp_out_bitmap_caps(s);
694          rdp_out_order_caps(s);          rdp_out_order_caps(s);
695          rdp_out_bmpcache_caps(s);          g_use_rdp5 ? rdp_out_bmpcache2_caps(s) : rdp_out_bmpcache_caps(s);
696          rdp_out_colcache_caps(s);          rdp_out_colcache_caps(s);
697          rdp_out_activate_caps(s);          rdp_out_activate_caps(s);
698          rdp_out_control_caps(s);          rdp_out_control_caps(s);
699          rdp_out_pointer_caps(s);          rdp_out_pointer_caps(s);
700          rdp_out_share_caps(s);          rdp_out_share_caps(s);
701          rdp_out_unknown_caps(s);  
702            rdp_out_unknown_caps(s, 0x0d, 0x58, caps_0x0d); /* international? */
703            rdp_out_unknown_caps(s, 0x0c, 0x08, caps_0x0c);
704            rdp_out_unknown_caps(s, 0x0e, 0x08, caps_0x0e);
705            rdp_out_unknown_caps(s, 0x10, 0x34, caps_0x10); /* glyph cache? */
706    
707          s_mark_end(s);          s_mark_end(s);
708          sec_send(s, sec_flags);          sec_send(s, sec_flags);
709  }  }
710    
711  /* Respond to a demand active PDU */  /* Process a general capability set */
712  static void  static void
713  process_demand_active(STREAM s)  rdp_process_general_caps(STREAM s)
714  {  {
715          uint8 type;          uint16 pad2octetsB;     /* rdp5 flags? */
         uint16 i;  
         uint16 p_bpp;  
716    
717          in_uint32_le(s, g_rdp_shareid);          in_uint8s(s, 10);
718            in_uint16_le(s, pad2octetsB);
719    
720            if (!pad2octetsB)
721                    g_use_rdp5 = False;
722    }
723    
724    /* Process a bitmap capability set */
725    static void
726    rdp_process_bitmap_caps(STREAM s)
727    {
728            uint16 width, height, bpp;
729    
730            in_uint16_le(s, bpp);
731            in_uint8s(s, 6);
732    
733            in_uint16_le(s, width);
734            in_uint16_le(s, height);
735    
736            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
737    
738            /*
739             * The server may limit bpp and change the size of the desktop (for
740             * example when shadowing another session).
741             */
742            if (g_server_bpp != bpp)
743            {
744                    warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);
745                    g_server_bpp = bpp;
746            }
747            if (g_width != width || g_height != height)
748            {
749                    warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
750                            width, height);
751                    g_width = width;
752                    g_height = height;
753                    ui_resize_window();
754            }
755    }
756    
757    /* Process server capabilities */
758    void
759    rdp_process_server_caps(STREAM s, uint16 length)
760    {
761            int n;
762            uint8 *next, *start;
763            uint16 ncapsets, capset_type, capset_length;
764    
765          /* scan for prefered bpp */          start = s->p;
766          while (s_check_rem(s, 6))  
767            in_uint16_le(s, ncapsets);
768            in_uint8s(s, 2);        /* pad */
769    
770            for (n = 0; n < ncapsets; n++)
771          {          {
772                  in_uint16_le(s, i);                  if (s->p > start + length)
773                  if (i == RDP_CAPSET_BITMAP)                          return;
774    
775                    in_uint16_le(s, capset_type);
776                    in_uint16_le(s, capset_length);
777    
778                    next = s->p + capset_length - 4;
779    
780                    switch (capset_type)
781                  {                  {
782                          in_uint16_le(s, i);                          case RDP_CAPSET_GENERAL:
783                          if (i == RDP_CAPLEN_BITMAP)                                  rdp_process_general_caps(s);
784                          {                                  break;
785                                  in_uint16_le(s, p_bpp);  
786                                  if (p_bpp == 8 || p_bpp == 15 || p_bpp == 16 || p_bpp == 24)                          case RDP_CAPSET_BITMAP:
787                                  {                                  rdp_process_bitmap_caps(s);
788                                          if (p_bpp < g_server_bpp)                                  break;
                                         {  
                                                 warning("Server limited colour depth to %d bits\n",  
                                                         p_bpp);  
                                                 g_server_bpp = p_bpp;  
                                         }  
                                         break;  
                                 }  
                         }  
789                  }                  }
790    
791                    s->p = next;
792          }          }
793    }
794    
795    /* Respond to a demand active PDU */
796    static void
797    process_demand_active(STREAM s)
798    {
799            uint8 type;
800            uint16 len_src_descriptor, len_combined_caps;
801    
802            in_uint32_le(s, g_rdp_shareid);
803            in_uint16_le(s, len_src_descriptor);
804            in_uint16_le(s, len_combined_caps);
805            in_uint8s(s, len_src_descriptor);
806    
807          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
808            rdp_process_server_caps(s, len_combined_caps);
809    
810          rdp_send_confirm_active();          rdp_send_confirm_active();
811          rdp_send_synchronise();          rdp_send_synchronise();
# Line 658  process_demand_active(STREAM s) Line 815  process_demand_active(STREAM s)
815          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
816          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
817          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);
818          rdp_send_fonts(1);  
819          rdp_send_fonts(2);          if (g_use_rdp5)
820          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */          {
821                    rdp_enum_bmpcache2();
822                    rdp_send_fonts(3);
823            }
824            else
825            {
826                    rdp_send_fonts(1);
827                    rdp_send_fonts(2);
828            }
829    
830            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
831          reset_order_state();          reset_order_state();
832  }  }
833    
# Line 860  process_update_pdu(STREAM s) Line 1027  process_update_pdu(STREAM s)
1027    
1028          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
1029    
1030            ui_begin_update();
1031          switch (update_type)          switch (update_type)
1032          {          {
1033                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 883  process_update_pdu(STREAM s) Line 1051  process_update_pdu(STREAM s)
1051                  default:                  default:
1052                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
1053          }          }
1054            ui_end_update();
1055    }
1056    
1057    /* Process a disconnect PDU */
1058    void
1059    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
1060    {
1061            in_uint32_le(s, *ext_disc_reason);
1062    
1063            DEBUG(("Received disconnect PDU\n"));
1064  }  }
1065    
1066  /* Process data PDU */  /* Process data PDU */
1067  static void  static BOOL
1068  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
1069  {  {
1070          uint8 data_pdu_type;          uint8 data_pdu_type;
1071          uint8 ctype;          uint8 ctype;
1072          uint16 clen;          uint16 clen;
1073          int roff, rlen, len, ret;          uint32 len;
1074          static struct stream ns;  
1075          static signed char *dict = 0;          uint32 roff, rlen;
1076    
1077            struct stream *ns = &(g_mppc_dict.ns);
1078    
1079          in_uint8s(s, 6);        /* shareid, pad, streamid */          in_uint8s(s, 6);        /* shareid, pad, streamid */
1080          in_uint16(s, len);          in_uint16(s, len);
# Line 904  process_data_pdu(STREAM s) Line 1083  process_data_pdu(STREAM s)
1083          in_uint16(s, clen);          in_uint16(s, clen);
1084          clen -= 18;          clen -= 18;
1085    
1086  #if 0          if (ctype & RDP_MPPC_COMPRESSED)
         if (ctype & 0x20)  
1087          {          {
                 if (!dict)  
                 {  
                         dict = (signed char *) malloc(8200 * sizeof(signed char));  
                         dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));  
                 }  
1088    
1089                  ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1090                            error("error while decompressing packet\n");
1091    
1092                  len -= 18;                  //len -= 18;
1093    
1094                  ns.data = xrealloc(ns.data, len);                  /* allocate memory and copy the uncompressed data into the temporary stream */
1095                    ns->data = (uint8 *) xrealloc(ns->data, rlen);
1096    
1097                  ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);                  memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
1098    
1099                  ns.size = len;                  ns->size = rlen;
1100                  ns.end = ns.data + ns.size;                  ns->end = (ns->data + ns->size);
1101                  ns.p = ns.data;                  ns->p = ns->data;
1102                  ns.rdp_hdr = ns.p;                  ns->rdp_hdr = ns->p;
1103    
1104                  s = &ns;                  s = ns;
1105          }          }
 #endif  
1106    
1107          switch (data_pdu_type)          switch (data_pdu_type)
1108          {          {
# Line 936  process_data_pdu(STREAM s) Line 1110  process_data_pdu(STREAM s)
1110                          process_update_pdu(s);                          process_update_pdu(s);
1111                          break;                          break;
1112    
1113                    case RDP_DATA_PDU_CONTROL:
1114                            DEBUG(("Received Control PDU\n"));
1115                            break;
1116    
1117                    case RDP_DATA_PDU_SYNCHRONISE:
1118                            DEBUG(("Received Sync PDU\n"));
1119                            break;
1120    
1121                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1122                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1123                          break;                          break;
# Line 950  process_data_pdu(STREAM s) Line 1132  process_data_pdu(STREAM s)
1132                          break;                          break;
1133    
1134                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
1135                          /* Normally received when user logs out or disconnects from a                          process_disconnect_pdu(s, ext_disc_reason);
1136                             console session on Windows XP and 2003 Server */                          return True;
                         DEBUG(("Received disconnect PDU\n"));  
                         break;  
1137    
1138                  default:                  default:
1139                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1140          }          }
1141            return False;
1142  }  }
1143    
1144  /* Process incoming packets */  /* Process incoming packets */
1145    /* nevers gets out of here till app is done */
1146    void
1147    rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1148    {
1149            while (rdp_loop(deactivated, ext_disc_reason))
1150                    ;
1151    }
1152    
1153    /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1154  BOOL  BOOL
1155  rdp_main_loop(void)  rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1156  {  {
1157          uint8 type;          uint8 type;
1158            BOOL disc = False;      /* True when a disconnect PDU was received */
1159            BOOL cont = True;
1160          STREAM s;          STREAM s;
1161    
1162          while ((s = rdp_recv(&type)) != NULL)          while (cont)
1163          {          {
1164                    s = rdp_recv(&type);
1165                    if (s == NULL)
1166                            return False;
1167                  switch (type)                  switch (type)
1168                  {                  {
1169                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1170                                  process_demand_active(s);                                  process_demand_active(s);
1171                                    *deactivated = False;
1172                                  break;                                  break;
   
1173                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1174                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1175                                  /* 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; */  
1176                                  break;                                  break;
   
1177                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1178                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1179                                  break;                                  break;
   
1180                          case 0:                          case 0:
1181                                  break;                                  break;
   
1182                          default:                          default:
1183                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1184                  }                  }
1185                    if (disc)
1186                            return False;
1187                    cont = g_next_packet < s->end;
1188          }          }
1189          return True;          return True;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1190  }  }
1191    
1192  /* 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.738
  ViewVC Help
Powered by ViewVC 1.1.26