/[rdesktop]/jpeg/rdesktop/trunk/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 /jpeg/rdesktop/trunk/rdp.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 879 by astrand, Sun Apr 3 18:08:05 2005 UTC revision 1429 by astrand, Thu Jan 24 08:06:02 2008 UTC
# Line 1  Line 1 
1  /* -*- c-basic-offset: 8 -*-  /* -*- c-basic-offset: 8 -*-
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     Protocol services - RDP layer     Protocol services - RDP layer
4     Copyright (C) Matthew Chapman 1999-2005     Copyright (C) Matthew Chapman 1999-2007
5    
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
# Line 19  Line 19 
19  */  */
20    
21  #include <time.h>  #include <time.h>
22    #ifndef _WIN32
23  #include <errno.h>  #include <errno.h>
24  #include <unistd.h>  #include <unistd.h>
25    #endif
26  #include "rdesktop.h"  #include "rdesktop.h"
27    
28  #ifdef HAVE_ICONV  #ifdef HAVE_ICONV
# Line 36  Line 38 
38  extern uint16 g_mcs_userid;  extern uint16 g_mcs_userid;
39  extern char g_username[64];  extern char g_username[64];
40  extern char g_codepage[16];  extern char g_codepage[16];
41  extern BOOL g_bitmap_compression;  extern RD_BOOL g_bitmap_compression;
42  extern BOOL g_orders;  extern RD_BOOL g_orders;
43  extern BOOL g_encryption;  extern RD_BOOL g_encryption;
44  extern BOOL g_desktop_save;  extern RD_BOOL g_desktop_save;
45  extern BOOL g_polygon_ellipse_orders;  extern RD_BOOL g_polygon_ellipse_orders;
46  extern BOOL g_use_rdp5;  extern RD_BOOL g_use_rdp5;
47  extern uint16 g_server_rdp_version;  extern uint16 g_server_rdp_version;
48  extern uint32 g_rdp5_performanceflags;  extern uint32 g_rdp5_performanceflags;
49  extern int g_server_bpp;  extern int g_server_depth;
50  extern int g_width;  extern int g_width;
51  extern int g_height;  extern int g_height;
52  extern BOOL g_bitmap_cache;  extern RD_BOOL g_bitmap_cache;
53  extern BOOL g_bitmap_cache_persist_enable;  extern RD_BOOL g_bitmap_cache_persist_enable;
54    extern RD_BOOL g_numlock_sync;
55    
56  uint8 *g_next_packet;  uint8 *g_next_packet;
57  uint32 g_rdp_shareid;  uint32 g_rdp_shareid;
58    
59  extern RDPCOMP g_mppc_dict;  extern RDPCOMP g_mppc_dict;
60    
61    /* Session Directory support */
62    extern RD_BOOL g_redirect;
63    extern char g_redirect_server[64];
64    extern char g_redirect_domain[16];
65    extern char g_redirect_password[64];
66    extern char g_redirect_username[64];
67    extern char g_redirect_cookie[128];
68    extern uint32 g_redirect_flags;
69    /* END Session Directory support */
70    
71  #if WITH_DEBUG  #if WITH_DEBUG
72  static uint32 g_packetno;  static uint32 g_packetno;
73  #endif  #endif
74    
75  #ifdef HAVE_ICONV  #ifdef HAVE_ICONV
76  static BOOL g_iconv_works = True;  static RD_BOOL g_iconv_works = True;
77  #endif  #endif
78    
79  /* Receive an RDP packet */  /* Receive an RDP packet */
# Line 71  rdp_recv(uint8 * type) Line 84  rdp_recv(uint8 * type)
84          uint16 length, pdu_type;          uint16 length, pdu_type;
85          uint8 rdpver;          uint8 rdpver;
86    
87          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end))          if ((rdp_s == NULL) || (g_next_packet >= rdp_s->end) || (g_next_packet == NULL))
88          {          {
89                  rdp_s = sec_recv(&rdpver);                  rdp_s = sec_recv(&rdpver);
90                  if (rdp_s == NULL)                  if (rdp_s == NULL)
# Line 172  rdp_out_unistr(STREAM s, char *string, i Line 185  rdp_out_unistr(STREAM s, char *string, i
185                          size_t i = 1, o = 4;                          size_t i = 1, o = 4;
186                          if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t) - 1)                          if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t) - 1)
187                          {                          {
188                                  warning("rdp_out_unistr: iconv_open[%s -> %s] fail %d\n",                                  warning("rdp_out_unistr: iconv_open[%s -> %s] fail %p\n",
189                                          g_codepage, WINDOWS_CODEPAGE, (int) iconv_h);                                          g_codepage, WINDOWS_CODEPAGE, iconv_h);
190    
191                                  g_iconv_works = False;                                  g_iconv_works = False;
192                                  rdp_out_unistr(s, string, len);                                  rdp_out_unistr(s, string, len);
# Line 230  rdp_out_unistr(STREAM s, char *string, i Line 243  rdp_out_unistr(STREAM s, char *string, i
243   * Returns str_len of string   * Returns str_len of string
244   */   */
245  int  int
246  rdp_in_unistr(STREAM s, char *string, int uni_len)  rdp_in_unistr(STREAM s, char *string, int str_size, int in_len)
247  {  {
248  #ifdef HAVE_ICONV  #ifdef HAVE_ICONV
249          size_t ibl = uni_len, obl = uni_len;          size_t ibl = in_len, obl = str_size - 1;
250          char *pin = (char *) s->p, *pout = string;          char *pin = (char *) s->p, *pout = string;
251          static iconv_t iconv_h = (iconv_t) - 1;          static iconv_t iconv_h = (iconv_t) - 1;
252    
# Line 243  rdp_in_unistr(STREAM s, char *string, in Line 256  rdp_in_unistr(STREAM s, char *string, in
256                  {                  {
257                          if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)                          if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)
258                          {                          {
259                                  warning("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",                                  warning("rdp_in_unistr: iconv_open[%s -> %s] fail %p\n",
260                                          WINDOWS_CODEPAGE, g_codepage, (int) iconv_h);                                          WINDOWS_CODEPAGE, g_codepage, iconv_h);
261    
262                                  g_iconv_works = False;                                  g_iconv_works = False;
263                                  return rdp_in_unistr(s, string, uni_len);                                  return rdp_in_unistr(s, string, str_size, in_len);
264                          }                          }
265                  }                  }
266    
267                  if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)                  if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
268                  {                  {
269                          iconv_close(iconv_h);                          if (errno == E2BIG)
270                          iconv_h = (iconv_t) - 1;                          {
271                          warning("rdp_in_unistr: iconv fail, errno %d\n", errno);                                  warning("server sent an unexpectedly long string, truncating\n");
272                            }
273                            else
274                            {
275                                    iconv_close(iconv_h);
276                                    iconv_h = (iconv_t) - 1;
277                                    warning("rdp_in_unistr: iconv fail, errno %d\n", errno);
278    
279                          g_iconv_works = False;                                  g_iconv_works = False;
280                          return rdp_in_unistr(s, string, uni_len);                                  return rdp_in_unistr(s, string, str_size, in_len);
281                            }
282                  }                  }
283    
284                    /* we must update the location of the current STREAM for future reads of s->p */
285                    s->p += in_len;
286    
287                    *pout = 0;
288                  return pout - string;                  return pout - string;
289          }          }
290          else          else
291  #endif  #endif
292          {          {
293                  int i = 0;                  int i = 0;
294                    int len = in_len / 2;
295                    int rem = 0;
296    
297                    if (len > str_size - 1)
298                    {
299                            warning("server sent an unexpectedly long string, truncating\n");
300                            len = str_size - 1;
301                            rem = in_len - 2 * len;
302                    }
303    
304                  while (i < uni_len / 2)                  while (i < len)
305                  {                  {
306                          in_uint8a(s, &string[i++], 1);                          in_uint8a(s, &string[i++], 1);
307                          in_uint8s(s, 1);                          in_uint8s(s, 1);
308                  }                  }
309    
310                  return i - 1;                  in_uint8s(s, rem);
311                    string[len] = 0;
312                    return len;
313          }          }
314  }  }
315    
# Line 297  rdp_send_logon_info(uint32 flags, char * Line 333  rdp_send_logon_info(uint32 flags, char *
333          time_t t = time(NULL);          time_t t = time(NULL);
334          time_t tzone;          time_t tzone;
335    
 #if 0  
         /* enable rdp compression */  
         /* some problems still exist with rdp5 */  
         flags |= RDP_COMPRESSION;  
 #endif  
   
336          if (!g_use_rdp5 || 1 == g_server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
337          {          {
338                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
# Line 427  rdp_send_logon_info(uint32 flags, char * Line 457  rdp_send_logon_info(uint32 flags, char *
457                  out_uint32_le(s, 0xffffffc4);                  out_uint32_le(s, 0xffffffc4);
458                  out_uint32_le(s, 0xfffffffe);                  out_uint32_le(s, 0xfffffffe);
459                  out_uint32_le(s, g_rdp5_performanceflags);                  out_uint32_le(s, g_rdp5_performanceflags);
460                  out_uint32(s, 0);                  out_uint16(s, 0);
461    
462    
463          }          }
# Line 487  rdp_send_input(uint32 time, uint16 messa Line 517  rdp_send_input(uint32 time, uint16 messa
517          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
518  }  }
519    
520  /* Inform the server on the contents of the persistent bitmap cache */  /* Send a client window information PDU */
521    void
522    rdp_send_client_window_status(int status)
523    {
524            STREAM s;
525            static int current_status = 1;
526    
527            if (current_status == status)
528                    return;
529    
530            s = rdp_init_data(12);
531    
532            out_uint32_le(s, status);
533    
534            switch (status)
535            {
536                    case 0: /* shut the server up */
537                            break;
538    
539                    case 1: /* receive data again */
540                            out_uint32_le(s, 0);    /* unknown */
541                            out_uint16_le(s, g_width);
542                            out_uint16_le(s, g_height);
543                            break;
544            }
545    
546            s_mark_end(s);
547            rdp_send_data(s, RDP_DATA_PDU_CLIENT_WINDOW_STATUS);
548            current_status = status;
549    }
550    
551    /* Send persistent bitmap cache enumeration PDU's */
552  static void  static void
553  rdp_enum_bmpcache2(void)  rdp_enum_bmpcache2(void)
554  {  {
# Line 581  rdp_out_bitmap_caps(STREAM s) Line 642  rdp_out_bitmap_caps(STREAM s)
642          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
643          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
644    
645          out_uint16_le(s, g_server_bpp); /* Preferred BPP */          out_uint16_le(s, g_server_depth);       /* Preferred colour depth */
646          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
647          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
648          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
# Line 645  rdp_out_bmpcache_caps(STREAM s) Line 706  rdp_out_bmpcache_caps(STREAM s)
706          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
707          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
708    
709          Bpp = (g_server_bpp + 7) / 8;          Bpp = (g_server_depth + 7) / 8; /* bytes per pixel */
710          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
711          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
712          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
# Line 664  rdp_out_bmpcache2_caps(STREAM s) Line 725  rdp_out_bmpcache2_caps(STREAM s)
725    
726          out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */          out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
727    
728          out_uint16_le(s, 0x0300);       /* flags? number of caches? */          out_uint16_be(s, 3);    /* number of caches in this set */
729    
730            /* max cell size for cache 0 is 16x16, 1 = 32x32, 2 = 64x64, etc */
731          out_uint32_le(s, BMPCACHE2_C0_CELLS);          out_uint32_le(s, BMPCACHE2_C0_CELLS);
732          out_uint32_le(s, BMPCACHE2_C1_CELLS);          out_uint32_le(s, BMPCACHE2_C1_CELLS);
733          if (pstcache_init(2))          if (pstcache_init(2))
# Line 841  rdp_process_general_caps(STREAM s) Line 903  rdp_process_general_caps(STREAM s)
903  static void  static void
904  rdp_process_bitmap_caps(STREAM s)  rdp_process_bitmap_caps(STREAM s)
905  {  {
906          uint16 width, height, bpp;          uint16 width, height, depth;
907    
908          in_uint16_le(s, bpp);          in_uint16_le(s, depth);
909          in_uint8s(s, 6);          in_uint8s(s, 6);
910    
911          in_uint16_le(s, width);          in_uint16_le(s, width);
912          in_uint16_le(s, height);          in_uint16_le(s, height);
913    
914          DEBUG(("setting desktop size and bpp to: %dx%dx%d\n", width, height, bpp));          DEBUG(("setting desktop size and depth to: %dx%dx%d\n", width, height, depth));
915    
916          /*          /*
917           * The server may limit bpp and change the size of the desktop (for           * The server may limit depth and change the size of the desktop (for
918           * example when shadowing another session).           * example when shadowing another session).
919           */           */
920          if (g_server_bpp != bpp)          if (g_server_depth != depth)
921          {          {
922                  warning("colour depth changed from %d to %d\n", g_server_bpp, bpp);                  warning("Remote desktop does not support colour depth %d; falling back to %d\n",
923                  g_server_bpp = bpp;                          g_server_depth, depth);
924                    g_server_depth = depth;
925          }          }
926          if (g_width != width || g_height != height)          if (g_width != width || g_height != height)
927          {          {
928                  warning("screen size changed from %dx%d to %dx%d\n", g_width, g_height,                  warning("Remote desktop changed from %dx%d to %dx%d.\n", g_width, g_height,
929                          width, height);                          width, height);
930                  g_width = width;                  g_width = width;
931                  g_height = height;                  g_height = height;
# Line 871  rdp_process_bitmap_caps(STREAM s) Line 934  rdp_process_bitmap_caps(STREAM s)
934  }  }
935    
936  /* Process server capabilities */  /* Process server capabilities */
937  void  static void
938  rdp_process_server_caps(STREAM s, uint16 length)  rdp_process_server_caps(STREAM s, uint16 length)
939  {  {
940          int n;          int n;
# Line 930  process_demand_active(STREAM s) Line 993  process_demand_active(STREAM s)
993          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
994          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
995          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
996          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0,
997                           g_numlock_sync ? ui_get_numlock_state(read_keyboard_state()) : 0, 0);
998    
999          if (g_use_rdp5)          if (g_use_rdp5)
1000          {          {
# Line 953  process_colour_pointer_pdu(STREAM s) Line 1017  process_colour_pointer_pdu(STREAM s)
1017  {  {
1018          uint16 x, y, width, height, cache_idx, masklen, datalen;          uint16 x, y, width, height, cache_idx, masklen, datalen;
1019          uint8 *mask, *data;          uint8 *mask, *data;
1020          HCURSOR cursor;          RD_HCURSOR cursor;
1021    
1022          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
1023          in_uint16_le(s, x);          in_uint16_le(s, x);
# Line 985  process_system_pointer_pdu(STREAM s) Line 1049  process_system_pointer_pdu(STREAM s)
1049  {  {
1050          uint16 system_pointer_type;          uint16 system_pointer_type;
1051    
1052          in_uint16(s, system_pointer_type);          in_uint16_le(s, system_pointer_type);
1053          switch (system_pointer_type)          switch (system_pointer_type)
1054          {          {
1055                  case RDP_NULL_POINTER:                  case RDP_NULL_POINTER:
# Line 1110  process_palette(STREAM s) Line 1174  process_palette(STREAM s)
1174  {  {
1175          COLOURENTRY *entry;          COLOURENTRY *entry;
1176          COLOURMAP map;          COLOURMAP map;
1177          HCOLOURMAP hmap;          RD_HCOLOURMAP hmap;
1178          int i;          int i;
1179    
1180          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
# Line 1180  process_disconnect_pdu(STREAM s, uint32 Line 1244  process_disconnect_pdu(STREAM s, uint32
1244  }  }
1245    
1246  /* Process data PDU */  /* Process data PDU */
1247  static BOOL  static RD_BOOL
1248  process_data_pdu(STREAM s, uint32 * ext_disc_reason)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
1249  {  {
1250          uint8 data_pdu_type;          uint8 data_pdu_type;
# Line 1193  process_data_pdu(STREAM s, uint32 * ext_ Line 1257  process_data_pdu(STREAM s, uint32 * ext_
1257          struct stream *ns = &(g_mppc_dict.ns);          struct stream *ns = &(g_mppc_dict.ns);
1258    
1259          in_uint8s(s, 6);        /* shareid, pad, streamid */          in_uint8s(s, 6);        /* shareid, pad, streamid */
1260          in_uint16(s, len);          in_uint16_le(s, len);
1261          in_uint8(s, data_pdu_type);          in_uint8(s, data_pdu_type);
1262          in_uint8(s, ctype);          in_uint8(s, ctype);
1263          in_uint16(s, clen);          in_uint16_le(s, clen);
1264          clen -= 18;          clen -= 18;
1265    
1266          if (ctype & RDP_MPPC_COMPRESSED)          if (ctype & RDP_MPPC_COMPRESSED)
# Line 1250  process_data_pdu(STREAM s, uint32 * ext_ Line 1314  process_data_pdu(STREAM s, uint32 * ext_
1314    
1315                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
1316                          process_disconnect_pdu(s, ext_disc_reason);                          process_disconnect_pdu(s, ext_disc_reason);
1317                          return True;  
1318                            /* We used to return true and disconnect immediately here, but
1319                             * Windows Vista sends a disconnect PDU with reason 0 when
1320                             * reconnecting to a disconnected session, and MSTSC doesn't
1321                             * drop the connection.  I think we should just save the status.
1322                             */
1323                            break;
1324    
1325                  default:                  default:
1326                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
# Line 1258  process_data_pdu(STREAM s, uint32 * ext_ Line 1328  process_data_pdu(STREAM s, uint32 * ext_
1328          return False;          return False;
1329  }  }
1330    
1331    /* Process redirect PDU from Session Directory */
1332    static RD_BOOL
1333    process_redirect_pdu(STREAM s /*, uint32 * ext_disc_reason */ )
1334    {
1335            uint32 len;
1336    
1337            /* these 2 bytes are unknown, seem to be zeros */
1338            in_uint8s(s, 2);
1339    
1340            /* read connection flags */
1341            in_uint32_le(s, g_redirect_flags);
1342    
1343            /* read length of ip string */
1344            in_uint32_le(s, len);
1345    
1346            /* read ip string */
1347            rdp_in_unistr(s, g_redirect_server, sizeof(g_redirect_server), len);
1348    
1349            /* read length of cookie string */
1350            in_uint32_le(s, len);
1351    
1352            /* read cookie string (plain ASCII) */
1353            if (len > sizeof(g_redirect_cookie) - 1)
1354            {
1355                    uint32 rem = len - (sizeof(g_redirect_cookie) - 1);
1356                    len = sizeof(g_redirect_cookie) - 1;
1357    
1358                    warning("Unexpectedly large redirection cookie\n");
1359                    in_uint8a(s, g_redirect_cookie, len);
1360                    in_uint8s(s, rem);
1361            }
1362            else
1363            {
1364                    in_uint8a(s, g_redirect_cookie, len);
1365            }
1366            g_redirect_cookie[len] = 0;
1367    
1368            /* read length of username string */
1369            in_uint32_le(s, len);
1370    
1371            /* read username string */
1372            rdp_in_unistr(s, g_redirect_username, sizeof(g_redirect_username), len);
1373    
1374            /* read length of domain string */
1375            in_uint32_le(s, len);
1376    
1377            /* read domain string */
1378            rdp_in_unistr(s, g_redirect_domain, sizeof(g_redirect_domain), len);
1379    
1380            /* read length of password string */
1381            in_uint32_le(s, len);
1382    
1383            /* read password string */
1384            rdp_in_unistr(s, g_redirect_password, sizeof(g_redirect_password), len);
1385    
1386            g_redirect = True;
1387    
1388            return True;
1389    }
1390    
1391  /* Process incoming packets */  /* Process incoming packets */
1392  /* nevers gets out of here till app is done */  /* nevers gets out of here till app is done */
1393  void  void
1394  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_main_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason)
1395  {  {
1396          while (rdp_loop(deactivated, ext_disc_reason))          while (rdp_loop(deactivated, ext_disc_reason))
1397                  ;                  ;
1398  }  }
1399    
1400  /* used in uiports and rdp_main_loop, processes the rdp packets waiting */  /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1401  BOOL  RD_BOOL
1402  rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason)
1403  {  {
1404          uint8 type;          uint8 type;
1405          BOOL disc = False;      /* True when a disconnect PDU was received */          RD_BOOL disc = False;   /* True when a disconnect PDU was received */
1406          BOOL cont = True;          RD_BOOL cont = True;
1407          STREAM s;          STREAM s;
1408    
1409          while (cont)          while (cont)
# Line 1291  rdp_loop(BOOL * deactivated, uint32 * ex Line 1421  rdp_loop(BOOL * deactivated, uint32 * ex
1421                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1422                                  *deactivated = True;                                  *deactivated = True;
1423                                  break;                                  break;
1424                            case RDP_PDU_REDIRECT:
1425                                    return process_redirect_pdu(s);
1426                                    break;
1427                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1428                                  disc = process_data_pdu(s, ext_disc_reason);                                  disc = process_data_pdu(s, ext_disc_reason);
1429                                  break;                                  break;
# Line 1307  rdp_loop(BOOL * deactivated, uint32 * ex Line 1440  rdp_loop(BOOL * deactivated, uint32 * ex
1440  }  }
1441    
1442  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
1443  BOOL  RD_BOOL
1444  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1445              char *command, char *directory)              char *command, char *directory)
1446  {  {
# Line 1318  rdp_connect(char *server, uint32 flags, Line 1451  rdp_connect(char *server, uint32 flags,
1451          return True;          return True;
1452  }  }
1453    
1454    /* Establish a reconnection up to the RDP layer */
1455    RD_BOOL
1456    rdp_reconnect(char *server, uint32 flags, char *domain, char *password,
1457                  char *command, char *directory, char *cookie)
1458    {
1459            if (!sec_reconnect(server))
1460                    return False;
1461    
1462            rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1463            return True;
1464    }
1465    
1466    /* Called during redirection to reset the state to support redirection */
1467    void
1468    rdp_reset_state(void)
1469    {
1470            g_next_packet = NULL;   /* reset the packet information */
1471            g_rdp_shareid = 0;
1472            sec_reset_state();
1473    }
1474    
1475  /* Disconnect from the RDP layer */  /* Disconnect from the RDP layer */
1476  void  void
1477  rdp_disconnect(void)  rdp_disconnect(void)
Legend:
Removed from v.879  
changed lines
  Added in v.1429
  ViewVC Help
Powered by ViewVC 1.1.26