/[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 532 by astrand, Wed Oct 29 14:14:46 2003 UTC revision 717 by astrand, Thu Jun 17 09:42:58 2004 UTC
# 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 <time.h>
22  #include "rdesktop.h"  #include "rdesktop.h"
23    
24  extern uint16 g_mcs_userid;  extern uint16 g_mcs_userid;
# Line 28  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    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 131  rdp_out_unistr(STREAM s, char *string, i Line 138  rdp_out_unistr(STREAM s, char *string, i
138          s->p += len;          s->p += len;
139  }  }
140    
141    /* Input a string in Unicode
142     *
143     * Returns str_len of string
144     */
145    int
146    rdp_in_unistr(STREAM s, char *string, int uni_len)
147    {
148            int i = 0;
149    
150            while (i < uni_len / 2)
151            {
152                    in_uint8a(s, &string[i++], 1);
153                    in_uint8s(s, 1);
154            }
155    
156            return i - 1;
157    }
158    
159    
160  /* Parse a logon info packet */  /* Parse a logon info packet */
161  static void  static void
162  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
163                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
164  {  {
165            char *ipaddr = tcp_get_address();
166          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
167          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
168          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
169          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
170          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
171          int len_ip = 2 * strlen("127.0.0.1");          int len_ip = 2 * strlen(ipaddr);
172          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
173          int packetlen = 0;          int packetlen = 0;
174          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;
175          STREAM s;          STREAM s;
176            time_t t = time(NULL);
177            time_t tzone;
178    
179    #if 0
180            /* enable rdp compression */
181            /* some problems still exist with rdp5 */
182            flags |= RDP_COMPRESSION;
183    #endif
184    
185          if (!g_use_rdp5 || 1 == g_server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
186          {          {
# Line 169  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 */
211                          4 +     // flags                          4 +     /* flags */
212                          2 +     // len_domain                          2 +     /* len_domain */
213                          2 +     // len_user                          2 +     /* len_user */
214                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      // len_password                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
215                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      // Length of BLOB                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
216                          2 +     // len_program                          2 +     /* len_program */
217                          2 +     // len_directory                          2 +     /* len_directory */
218                          (0 < len_domain ? len_domain : 2) +     // domain                          (0 < len_domain ? len_domain : 2) +     /* domain */
219                          len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    // We have no 512 byte BLOB. Perhaps we must?                          len_user + (flags & RDP_LOGON_AUTO ? len_password : 0) + 0 +    /* We have no 512 byte BLOB. Perhaps we must? */
220                          (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + // After the BLOB is a unknown int16. If there is a BLOB, that is.                          (flags & RDP_LOGON_BLOB && !(flags & RDP_LOGON_AUTO) ? 2 : 0) + /* After the BLOB is a unknown int16. If there is a BLOB, that is. */
221                          (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     // Unknown (2)                          (0 < len_program ? len_program : 2) + (0 < len_directory ? len_directory : 2) + 2 +     /* Unknown (2) */
222                          2 +     // Client ip length                          2 +     /* Client ip length */
223                          len_ip +        // Client ip                          len_ip +        /* Client ip */
224                          2 +     // DLL string length                          2 +     /* DLL string length */
225                          len_dll +       // DLL string                          len_dll +       /* DLL string */
226                          2 +     // Unknown                          2 +     /* Unknown */
227                          2 +     // Unknown                          2 +     /* Unknown */
228                          64 +    // Time zone #0                          64 +    /* Time zone #0 */
229                          2 +     // Unknown                          2 +     /* Unknown */
230                          64 +    // Time zone #1                          64 +    /* Time zone #1 */
231                          32;     // Unknown                          32;     /* Unknown */
232    
233                  s = sec_init(sec_flags, packetlen);                  s = sec_init(sec_flags, packetlen);
234                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
235    
236                  out_uint32(s, 0);       // Unknown                  out_uint32(s, 0);       /* Unknown */
237                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
238                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
239                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
# Line 243  rdp_send_logon_info(uint32 flags, char * Line 279  rdp_send_logon_info(uint32 flags, char *
279                          out_uint16_le(s, 0);                          out_uint16_le(s, 0);
280                  }                  }
281                  out_uint16_le(s, 2);                  out_uint16_le(s, 2);
282                  out_uint16_le(s, len_ip + 2);   // Length of client ip                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
283                  rdp_out_unistr(s, "127.0.0.1", len_ip);                  rdp_out_unistr(s, ipaddr, len_ip);
284                  out_uint16_le(s, len_dll + 2);                  out_uint16_le(s, len_dll + 2);
285                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
286                  out_uint16_le(s, 0xffc4);  
287                  out_uint16_le(s, 0xffff);                  tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
288                    out_uint32_le(s, tzone);
289    
290                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
291                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
292    
   
293                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
294                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
295                  out_uint32_le(s, 3);                  out_uint32_le(s, 3);
# Line 268  rdp_send_logon_info(uint32 flags, char * Line 305  rdp_send_logon_info(uint32 flags, char *
305                  out_uint32(s, 0);                  out_uint32(s, 0);
306                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
307                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
308                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
309                  out_uint32(s, 0);                  out_uint32(s, 0);
310    
311    
# Line 338  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 379  rdp_out_bitmap_caps(STREAM s) Line 416  rdp_out_bitmap_caps(STREAM s)
416          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
417          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
418    
419          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
420          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
421          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
422          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
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 404  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 583  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            if (g_server_bpp != bpp)
655            {
656                    warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);
657                    g_server_bpp = bpp;
658            }
659            if (g_width != width || g_height != height)
660            {
661                    warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,
662                            width, height);
663                    g_width = width;
664                    g_height = height;
665                    ui_resize_window();
666            }
667    }
668    
669  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
670  static void  static void
671  process_demand_active(STREAM s)  process_demand_active(STREAM s)
672  {  {
673          uint8 type;          int n;
674            uint8 type, *next;
675            uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;
676    
677          in_uint32_le(s, g_rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
678            in_uint16_le(s, len_src_descriptor);
679            in_uint16_le(s, len_combined_caps);
680            in_uint8s(s, len_src_descriptor);
681    
682            in_uint16_le(s, num_capsets);
683            in_uint8s(s, 2);        /* pad */
684    
685          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));          DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));
686    
687            for (n = 0; n < num_capsets; n++)
688            {
689                    in_uint16_le(s, capset_type);
690                    in_uint16_le(s, capset_length);
691    
692                    next = s->p + capset_length - 4;
693    
694                    switch (capset_type)
695                    {
696                            case RDP_CAPSET_GENERAL:
697                                    rdp_process_general_caps(s);
698                                    break;
699    
700                            case RDP_CAPSET_BITMAP:
701                                    rdp_process_bitmap_caps(s);
702                                    break;
703                    }
704    
705                    s->p = next;
706            }
707    
708          rdp_send_confirm_active();          rdp_send_confirm_active();
709          rdp_send_synchronise();          rdp_send_synchronise();
# Line 600  process_demand_active(STREAM s) Line 712  process_demand_active(STREAM s)
712          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
713          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
714          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
715          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);
716          rdp_send_fonts(1);  
717          rdp_send_fonts(2);          if (g_use_rdp5)
718          rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */          {
719                    rdp_send_fonts(3);
720            }
721            else
722            {
723                    rdp_send_fonts(1);
724                    rdp_send_fonts(2);
725            }
726    
727            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
728          reset_order_state();          reset_order_state();
729  }  }
730    
# Line 724  process_bitmap_updates(STREAM s) Line 845  process_bitmap_updates(STREAM s)
845                  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",
846                         left, top, right, bottom, width, height, Bpp, compress));                         left, top, right, bottom, width, height, Bpp, compress));
847    
                 /* 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;  
                 }  
   
848                  if (!compress)                  if (!compress)
849                  {                  {
850                          int y;                          int y;
# Line 810  process_update_pdu(STREAM s) Line 924  process_update_pdu(STREAM s)
924    
925          in_uint16_le(s, update_type);          in_uint16_le(s, update_type);
926    
927            ui_begin_update();
928          switch (update_type)          switch (update_type)
929          {          {
930                  case RDP_UPDATE_ORDERS:                  case RDP_UPDATE_ORDERS:
# Line 833  process_update_pdu(STREAM s) Line 948  process_update_pdu(STREAM s)
948                  default:                  default:
949                          unimpl("update %d\n", update_type);                          unimpl("update %d\n", update_type);
950          }          }
951            ui_end_update();
952    }
953    
954    /* Process a disconnect PDU */
955    void
956    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
957    {
958            in_uint32_le(s, *ext_disc_reason);
959    
960            DEBUG(("Received disconnect PDU\n"));
961  }  }
962    
963  /* Process data PDU */  /* Process data PDU */
964  static void  static BOOL
965  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
966  {  {
967          uint8 data_pdu_type;          uint8 data_pdu_type;
968            uint8 ctype;
969            uint16 clen;
970            uint32 len;
971    
972            uint32 roff, rlen;
973    
974            struct stream *ns = &(g_mppc_dict.ns);
975    
976          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          in_uint8s(s, 6);        /* shareid, pad, streamid */
977            in_uint16(s, len);
978          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
979          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
980            in_uint16(s, clen);
981            clen -= 18;
982    
983            if (ctype & RDP_MPPC_COMPRESSED)
984            {
985    
986                    if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
987                            error("error while decompressing packet\n");
988    
989                    //len -= 18;
990    
991                    /* allocate memory and copy the uncompressed data into the temporary stream */
992                    ns->data = (uint8 *) xrealloc(ns->data, rlen);
993    
994                    memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
995    
996                    ns->size = rlen;
997                    ns->end = (ns->data + ns->size);
998                    ns->p = ns->data;
999                    ns->rdp_hdr = ns->p;
1000    
1001                    s = ns;
1002            }
1003    
1004          switch (data_pdu_type)          switch (data_pdu_type)
1005          {          {
# Line 852  process_data_pdu(STREAM s) Line 1007  process_data_pdu(STREAM s)
1007                          process_update_pdu(s);                          process_update_pdu(s);
1008                          break;                          break;
1009    
1010                    case RDP_DATA_PDU_CONTROL:
1011                            DEBUG(("Received Control PDU\n"));
1012                            break;
1013    
1014                    case RDP_DATA_PDU_SYNCHRONISE:
1015                            DEBUG(("Received Sync PDU\n"));
1016                            break;
1017    
1018                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1019                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1020                          break;                          break;
# Line 866  process_data_pdu(STREAM s) Line 1029  process_data_pdu(STREAM s)
1029                          break;                          break;
1030    
1031                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
1032                          /* Normally received when user logs out or disconnects from a                          process_disconnect_pdu(s, ext_disc_reason);
1033                             console session on Windows XP and 2003 Server */                          return True;
                         DEBUG(("Received disconnect PDU\n"));  
                         break;  
1034    
1035                  default:                  default:
1036                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1037          }          }
1038            return False;
1039  }  }
1040    
1041  /* Process incoming packets */  /* Process incoming packets */
1042  BOOL  void
1043  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1044  {  {
1045          uint8 type;          uint8 type;
1046            BOOL disc = False;      /* True when a disconnect PDU was received */
1047          STREAM s;          STREAM s;
1048    
1049          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 889  rdp_main_loop(void) Line 1052  rdp_main_loop(void)
1052                  {                  {
1053                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1054                                  process_demand_active(s);                                  process_demand_active(s);
1055                                    *deactivated = False;
1056                                  break;                                  break;
1057    
1058                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1059                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1060                                  /* 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; */  
1061                                  break;                                  break;
1062    
1063                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1064                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1065                                  break;                                  break;
1066    
1067                          case 0:                          case 0:
# Line 911  rdp_main_loop(void) Line 1070  rdp_main_loop(void)
1070                          default:                          default:
1071                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1072                  }                  }
1073    
1074                    if (disc)
1075                    {
1076                            return;
1077                    }
1078            }
1079            return;
1080    }
1081    
1082    /* used in uiports, processes the rdp packets waiting */
1083    BOOL
1084    rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1085    {
1086            uint8 type;
1087            BOOL disc = False;      /* True when a disconnect PDU was received */
1088            BOOL cont = True;
1089            STREAM s;
1090    
1091            while (cont)
1092            {
1093                    s = rdp_recv(&type);
1094                    if (s == NULL)
1095                            return False;
1096                    switch (type)
1097                    {
1098                            case RDP_PDU_DEMAND_ACTIVE:
1099                                    process_demand_active(s);
1100                                    *deactivated = False;
1101                                    break;
1102                            case RDP_PDU_DEACTIVATE:
1103                                    DEBUG(("RDP_PDU_DEACTIVATE\n"));
1104                                    *deactivated = True;
1105                                    break;
1106                            case RDP_PDU_DATA:
1107                                    disc = process_data_pdu(s, ext_disc_reason);
1108                                    break;
1109                            case 0:
1110                                    break;
1111                            default:
1112                                    unimpl("PDU %d\n", type);
1113                    }
1114                    if (disc)
1115                            return False;
1116                    cont = g_next_packet < s->end;
1117          }          }
1118          return True;          return True;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1119  }  }
1120    
1121  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.532  
changed lines
  Added in v.717
  ViewVC Help
Powered by ViewVC 1.1.26