/[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 438 by jsorg71, Fri Aug 1 17:01:58 2003 UTC revision 678 by jsorg71, Mon Apr 26 22:31:22 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;
# Line 71  rdp_recv(uint8 * type) Line 76  rdp_recv(uint8 * type)
76    
77  #if WITH_DEBUG  #if WITH_DEBUG
78          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));          DEBUG(("RDP packet #%d, (type %x)\n", ++g_packetno, *type));
79          //      hexdump(g_next_packet, length);          hexdump(g_next_packet, length);
80  #endif /*  */  #endif /*  */
81    
82          g_next_packet += length;          g_next_packet += length;
# Line 131  rdp_out_unistr(STREAM s, char *string, i Line 136  rdp_out_unistr(STREAM s, char *string, i
136          s->p += len;          s->p += len;
137  }  }
138    
139    /* Input a string in Unicode
140     *
141     * Returns str_len of string
142     */
143    int
144    rdp_in_unistr(STREAM s, char *string, int uni_len)
145    {
146            int i = 0;
147    
148            while (i < uni_len / 2)
149            {
150                    in_uint8a(s, &string[i++], 1);
151                    in_uint8s(s, 1);
152            }
153    
154            return i - 1;
155    }
156    
157    
158  /* Parse a logon info packet */  /* Parse a logon info packet */
159  static void  static void
160  rdp_send_logon_info(uint32 flags, char *domain, char *user,  rdp_send_logon_info(uint32 flags, char *domain, char *user,
161                      char *password, char *program, char *directory)                      char *password, char *program, char *directory)
162  {  {
163            char *ipaddr = tcp_get_address();
164          int len_domain = 2 * strlen(domain);          int len_domain = 2 * strlen(domain);
165          int len_user = 2 * strlen(user);          int len_user = 2 * strlen(user);
166          int len_password = 2 * strlen(password);          int len_password = 2 * strlen(password);
167          int len_program = 2 * strlen(program);          int len_program = 2 * strlen(program);
168          int len_directory = 2 * strlen(directory);          int len_directory = 2 * strlen(directory);
169          int len_ip = 2 * strlen("127.0.0.1");          int len_ip = 2 * strlen(ipaddr);
170          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");          int len_dll = 2 * strlen("C:\\WINNT\\System32\\mstscax.dll");
171          int packetlen = 0;          int packetlen = 0;
172          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;
173          STREAM s;          STREAM s;
174            time_t t = time(NULL);
175            time_t tzone;
176    
177    #if 0
178            // enable rdp compression
179            flags |= RDP_COMPRESSION;
180    #endif
181    
182          if (!g_use_rdp5 || 1 == g_server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
183          {          {
# Line 171  rdp_send_logon_info(uint32 flags, char * Line 203  rdp_send_logon_info(uint32 flags, char *
203          {          {
204                  flags |= RDP_LOGON_BLOB;                  flags |= RDP_LOGON_BLOB;
205                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP5-style Logon packet\n"));
206                  packetlen = 4 + // Unknown uint32                  packetlen = 4 + /* Unknown uint32 */
207                          4 +     // flags                          4 +     /* flags */
208                          2 +     // len_domain                          2 +     /* len_domain */
209                          2 +     // len_user                          2 +     /* len_user */
210                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      // len_password                          (flags & RDP_LOGON_AUTO ? 2 : 0) +      /* len_password */
211                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      // Length of BLOB                          (flags & RDP_LOGON_BLOB ? 2 : 0) +      /* Length of BLOB */
212                          2 +     // len_program                          2 +     /* len_program */
213                          2 +     // len_directory                          2 +     /* len_directory */
214                          (0 < len_domain ? len_domain : 2) +     // domain                          (0 < len_domain ? len_domain : 2) +     /* domain */
215                          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? */
216                          (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. */
217                          (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) */
218                          2 +     // Client ip length                          2 +     /* Client ip length */
219                          len_ip +        // Client ip                          len_ip +        /* Client ip */
220                          2 +     // DLL string length                          2 +     /* DLL string length */
221                          len_dll +       // DLL string                          len_dll +       /* DLL string */
222                          2 +     // Unknown                          2 +     /* Unknown */
223                          2 +     // Unknown                          2 +     /* Unknown */
224                          64 +    // Time zone #0                          64 +    /* Time zone #0 */
225                          2 +     // Unknown                          2 +     /* Unknown */
226                          64 +    // Time zone #1                          64 +    /* Time zone #1 */
227                          32;     // Unknown                          32;     /* Unknown */
228    
229                  s = sec_init(sec_flags, packetlen);                  s = sec_init(sec_flags, packetlen);
230                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));                  DEBUG_RDP5(("Called sec_init with packetlen %d\n", packetlen));
231    
232                  out_uint32(s, 0);       // Unknown                  out_uint32(s, 0);       /* Unknown */
233                  out_uint32_le(s, flags);                  out_uint32_le(s, flags);
234                  out_uint16_le(s, len_domain);                  out_uint16_le(s, len_domain);
235                  out_uint16_le(s, len_user);                  out_uint16_le(s, len_user);
# Line 243  rdp_send_logon_info(uint32 flags, char * Line 275  rdp_send_logon_info(uint32 flags, char *
275                          out_uint16_le(s, 0);                          out_uint16_le(s, 0);
276                  }                  }
277                  out_uint16_le(s, 2);                  out_uint16_le(s, 2);
278                  out_uint16_le(s, len_ip + 2);   // Length of client ip                  out_uint16_le(s, len_ip + 2);   /* Length of client ip */
279                  rdp_out_unistr(s, "127.0.0.1", len_ip);                  rdp_out_unistr(s, ipaddr, len_ip);
280                  out_uint16_le(s, len_dll + 2);                  out_uint16_le(s, len_dll + 2);
281                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);                  rdp_out_unistr(s, "C:\\WINNT\\System32\\mstscax.dll", len_dll);
282                  out_uint16_le(s, 0xffc4);  
283                  out_uint16_le(s, 0xffff);                  tzone = (mktime(gmtime(&t)) - mktime(localtime(&t))) / 60;
284                    out_uint32_le(s, tzone);
285    
286                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));                  rdp_out_unistr(s, "GTB, normaltid", 2 * strlen("GTB, normaltid"));
287                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));                  out_uint8s(s, 62 - 2 * strlen("GTB, normaltid"));
288    
   
289                  out_uint32_le(s, 0x0a0000);                  out_uint32_le(s, 0x0a0000);
290                  out_uint32_le(s, 0x050000);                  out_uint32_le(s, 0x050000);
291                  out_uint32_le(s, 3);                  out_uint32_le(s, 3);
# Line 268  rdp_send_logon_info(uint32 flags, char * Line 301  rdp_send_logon_info(uint32 flags, char *
301                  out_uint32(s, 0);                  out_uint32(s, 0);
302                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
303                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
304                  out_uint32_le(s, 0x0f);                  out_uint32_le(s, g_rdp5_performanceflags);
305                  out_uint32(s, 0);                  out_uint32(s, 0);
306    
307    
# Line 338  rdp_send_fonts(uint16 seq) Line 371  rdp_send_fonts(uint16 seq)
371          s = rdp_init_data(8);          s = rdp_init_data(8);
372    
373          out_uint16(s, 0);       /* number of fonts */          out_uint16(s, 0);       /* number of fonts */
374          out_uint16_le(s, 0x3e); /* unknown */          out_uint16_le(s, 0);    /* pad? */
375          out_uint16_le(s, seq);  /* unknown */          out_uint16_le(s, seq);  /* unknown */
376          out_uint16_le(s, 0x32); /* entry size */          out_uint16_le(s, 0x32); /* entry size */
377    
# Line 379  rdp_out_bitmap_caps(STREAM s) Line 412  rdp_out_bitmap_caps(STREAM s)
412          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
413          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
414    
415          out_uint16_le(s, 8);    /* Preferred BPP */          out_uint16_le(s, g_server_bpp); /* Preferred BPP */
416          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
417          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
418          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
419          out_uint16_le(s, 800);  /* Desktop width */          out_uint16_le(s, 800);  /* Desktop width */
420          out_uint16_le(s, 600);  /* Desktop height */          out_uint16_le(s, 600);  /* Desktop height */
421          out_uint16(s, 0);       /* Pad */          out_uint16(s, 0);       /* Pad */
422          out_uint16(s, 0);       /* Allow resize */          out_uint16(s, 1);       /* Allow resize */
423          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */          out_uint16_le(s, g_bitmap_compression ? 1 : 0); /* Support compression */
424          out_uint16(s, 0);       /* Unknown */          out_uint16(s, 0);       /* Unknown */
425          out_uint16_le(s, 1);    /* Unknown */          out_uint16_le(s, 1);    /* Unknown */
# Line 404  rdp_out_order_caps(STREAM s) Line 437  rdp_out_order_caps(STREAM s)
437          order_caps[0] = 1;      /* dest blt */          order_caps[0] = 1;      /* dest blt */
438          order_caps[1] = 1;      /* pat blt */          order_caps[1] = 1;      /* pat blt */
439          order_caps[2] = 1;      /* screen blt */          order_caps[2] = 1;      /* screen blt */
440          order_caps[3] = 1;      /* required for memblt? */          order_caps[3] = (g_bitmap_cache ? 1 : 0); /* memblt */
441          order_caps[8] = 1;      /* line */          order_caps[8] = 1;      /* line */
442          order_caps[9] = 1;      /* line */          order_caps[9] = 1;      /* line */
443          order_caps[10] = 1;     /* rect */          order_caps[10] = 1;     /* rect */
# Line 583  rdp_send_confirm_active(void) Line 616  rdp_send_confirm_active(void)
616          sec_send(s, sec_flags);          sec_send(s, sec_flags);
617  }  }
618    
619    /* Process a general capability set */
620    static void
621    rdp_process_general_caps(STREAM s)
622    {
623            uint16 pad2octetsB;     /* rdp5 flags? */
624    
625            in_uint8s(s, 10);
626            in_uint16_le(s, pad2octetsB);
627    
628            if (!pad2octetsB)
629                    g_use_rdp5 = False;
630    }
631    
632    /* Process a bitmap capability set */
633    static void
634    rdp_process_bitmap_caps(STREAM s)
635    {
636            uint16 width, height, bpp;
637    
638            in_uint16_le(s, bpp);
639            in_uint8s(s, 6);
640    
641            in_uint16_le(s, width);
642            in_uint16_le(s, height);
643    
644            DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));
645    
646            /*
647             * The server may limit bpp and change the size of the desktop (for
648             * example when shadowing another session).
649             */
650            g_server_bpp = bpp;
651            g_width = width;
652            g_height = height;
653    
654            ui_resize_window();
655    }
656    
657  /* Respond to a demand active PDU */  /* Respond to a demand active PDU */
658  static void  static void
659  process_demand_active(STREAM s)  process_demand_active(STREAM s)
660  {  {
661          uint8 type;          int n;
662            uint8 type, *next;
663            uint16 len_src_descriptor, len_combined_caps, num_capsets, capset_type, capset_length;
664    
665          in_uint32_le(s, g_rdp_shareid);          in_uint32_le(s, g_rdp_shareid);
666            in_uint16_le(s, len_src_descriptor);
667            in_uint16_le(s, len_combined_caps);
668            in_uint8s(s, len_src_descriptor);
669    
670            in_uint16_le(s, num_capsets);
671            in_uint8s(s, 2);        /* pad */
672    
673            DEBUG(("DEMAND_ACTIVE(id=0x%x,num_caps=%d)\n", g_rdp_shareid, num_capsets));
674    
675            for (n = 0; n < num_capsets; n++)
676            {
677                    in_uint16_le(s, capset_type);
678                    in_uint16_le(s, capset_length);
679    
680          DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));                  next = s->p + capset_length - 4;
681    
682                    switch (capset_type)
683                    {
684                            case RDP_CAPSET_GENERAL:
685                                    rdp_process_general_caps(s);
686                                    break;
687    
688                            case RDP_CAPSET_BITMAP:
689                                    rdp_process_bitmap_caps(s);
690                                    break;
691                    }
692    
693                    s->p = next;
694            }
695    
696          rdp_send_confirm_active();          rdp_send_confirm_active();
697          rdp_send_synchronise();          rdp_send_synchronise();
# Line 600  process_demand_active(STREAM s) Line 700  process_demand_active(STREAM s)
700          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
701          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
702          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
703          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);
         rdp_send_fonts(1);  
         rdp_send_fonts(2);  
         rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 */  
         reset_order_state();  
 }  
704    
705  /* Process a null system pointer PDU */          if (g_use_rdp5)
706  void          {
707  process_null_system_pointer_pdu(STREAM s)                  rdp_send_fonts(3);
708  {          }
709          // FIXME: We should probably set another cursor here,          else
710          // like the X window system base cursor or something.          {
711          ui_set_cursor(cache_get_cursor(0));                  rdp_send_fonts(1);
712                    rdp_send_fonts(2);
713            }
714    
715            rdp_recv(&type);        /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
716            reset_order_state();
717  }  }
718    
719  /* Process a colour pointer PDU */  /* Process a colour pointer PDU */
# Line 648  process_cached_pointer_pdu(STREAM s) Line 748  process_cached_pointer_pdu(STREAM s)
748          ui_set_cursor(cache_get_cursor(cache_idx));          ui_set_cursor(cache_get_cursor(cache_idx));
749  }  }
750    
751    /* Process a system pointer PDU */
752    void
753    process_system_pointer_pdu(STREAM s)
754    {
755            uint16 system_pointer_type;
756    
757            in_uint16(s, system_pointer_type);
758            switch (system_pointer_type)
759            {
760                    case RDP_NULL_POINTER:
761                            ui_set_null_cursor();
762                            break;
763    
764                    default:
765                            unimpl("System pointer message 0x%x\n", system_pointer_type);
766            }
767    }
768    
769  /* Process a pointer PDU */  /* Process a pointer PDU */
770  static void  static void
# Line 676  process_pointer_pdu(STREAM s) Line 793  process_pointer_pdu(STREAM s)
793                          process_cached_pointer_pdu(s);                          process_cached_pointer_pdu(s);
794                          break;                          break;
795    
796                    case RDP_POINTER_SYSTEM:
797                            process_system_pointer_pdu(s);
798                            break;
799    
800                  default:                  default:
801                          DEBUG(("Pointer message 0x%x\n", message_type));                          unimpl("Pointer message 0x%x\n", message_type);
802          }          }
803  }  }
804    
# Line 817  process_update_pdu(STREAM s) Line 938  process_update_pdu(STREAM s)
938    
939  }  }
940    
941    /* Process a disconnect PDU */
942    void
943    process_disconnect_pdu(STREAM s, uint32 * ext_disc_reason)
944    {
945            in_uint32_le(s, *ext_disc_reason);
946    
947            DEBUG(("Received disconnect PDU\n"));
948    }
949    
950  /* Process data PDU */  /* Process data PDU */
951  static void  static BOOL
952  process_data_pdu(STREAM s)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
953  {  {
954          uint8 data_pdu_type;          uint8 data_pdu_type;
955            uint8 ctype;
956            uint16 clen;
957            int len;
958    #if 0
959            int roff, rlen, ret;
960            static struct stream ns;
961            static signed char *dict = 0;
962    #endif
963    
964          in_uint8s(s, 8);        /* shareid, pad, streamid, length */          in_uint8s(s, 6);        /* shareid, pad, streamid */
965            in_uint16(s, len);
966          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
967          in_uint8s(s, 3);        /* compress_type, compress_len */          in_uint8(s, ctype);
968            in_uint16(s, clen);
969            clen -= 18;
970    
971    #if 0
972            if (ctype & 0x20)
973            {
974                    if (!dict)
975                    {
976                            dict = (signed char *) malloc(8200 * sizeof(signed char));
977                            dict = (signed char *) memset(dict, 0, 8200 * sizeof(signed char));
978                    }
979    
980                    ret = decompress(s->p, clen, ctype, (signed char *) dict, &roff, &rlen);
981    
982                    len -= 18;
983    
984                    ns.data = xrealloc(ns.data, len);
985    
986                    ns.data = (unsigned char *) memcpy(ns.data, (unsigned char *) (dict + roff), len);
987    
988                    ns.size = len;
989                    ns.end = ns.data + ns.size;
990                    ns.p = ns.data;
991                    ns.rdp_hdr = ns.p;
992    
993                    s = &ns;
994            }
995    #endif
996    
997          switch (data_pdu_type)          switch (data_pdu_type)
998          {          {
# Line 833  process_data_pdu(STREAM s) Line 1000  process_data_pdu(STREAM s)
1000                          process_update_pdu(s);                          process_update_pdu(s);
1001                          break;                          break;
1002    
1003                    case RDP_DATA_PDU_CONTROL:
1004                            DEBUG(("Received Control PDU\n"));
1005                            break;
1006    
1007                    case RDP_DATA_PDU_SYNCHRONISE:
1008                            DEBUG(("Received Sync PDU\n"));
1009                            break;
1010    
1011                  case RDP_DATA_PDU_POINTER:                  case RDP_DATA_PDU_POINTER:
1012                          process_pointer_pdu(s);                          process_pointer_pdu(s);
1013                          break;                          break;
# Line 846  process_data_pdu(STREAM s) Line 1021  process_data_pdu(STREAM s)
1021                          /* User logged on */                          /* User logged on */
1022                          break;                          break;
1023    
1024                    case RDP_DATA_PDU_DISCONNECT:
1025                            process_disconnect_pdu(s, ext_disc_reason);
1026                            return True;
1027    
1028                  default:                  default:
1029                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
1030          }          }
1031            return False;
1032  }  }
1033    
1034  /* Process incoming packets */  /* Process incoming packets */
1035  BOOL  void
1036  rdp_main_loop(void)  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)
1037  {  {
1038          uint8 type;          uint8 type;
1039            BOOL disc = False;      /* True when a disconnect PDU was received */
1040          STREAM s;          STREAM s;
1041    
1042          while ((s = rdp_recv(&type)) != NULL)          while ((s = rdp_recv(&type)) != NULL)
# Line 864  rdp_main_loop(void) Line 1045  rdp_main_loop(void)
1045                  {                  {
1046                          case RDP_PDU_DEMAND_ACTIVE:                          case RDP_PDU_DEMAND_ACTIVE:
1047                                  process_demand_active(s);                                  process_demand_active(s);
1048                                    *deactivated = False;
1049                                  break;                                  break;
1050    
1051                          case RDP_PDU_DEACTIVATE:                          case RDP_PDU_DEACTIVATE:
1052                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1053                                  /* 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; */  
1054                                  break;                                  break;
1055    
1056                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1057                                  process_data_pdu(s);                                  disc = process_data_pdu(s, ext_disc_reason);
1058                                  break;                                  break;
1059    
1060                          case 0:                          case 0:
# Line 886  rdp_main_loop(void) Line 1063  rdp_main_loop(void)
1063                          default:                          default:
1064                                  unimpl("PDU %d\n", type);                                  unimpl("PDU %d\n", type);
1065                  }                  }
1066    
1067                    if (disc)
1068                    {
1069                            return;
1070                    }
1071          }          }
1072          return True;          return;
         /* We want to detect if we got a clean shutdown, but we  
            can't. Se above.    
            return False;  */  
1073  }  }
1074    
1075  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
Legend:
Removed from v.438  
changed lines
  Added in v.678
  ViewVC Help
Powered by ViewVC 1.1.26