/[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 858 by stargo, Sun Mar 13 13:58:23 2005 UTC revision 1372 by jsorg71, Mon Jan 8 04:47:06 2007 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
76    static RD_BOOL g_iconv_works = True;
77    #endif
78    
79  /* Receive an RDP packet */  /* Receive an RDP packet */
80  static STREAM  static STREAM
81  rdp_recv(uint8 * type)  rdp_recv(uint8 * type)
# Line 67  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 156  rdp_out_unistr(STREAM s, char *string, i Line 173  rdp_out_unistr(STREAM s, char *string, i
173  {  {
174  #ifdef HAVE_ICONV  #ifdef HAVE_ICONV
175          size_t ibl = strlen(string), obl = len + 2;          size_t ibl = strlen(string), obl = len + 2;
176          static iconv_t iconv_h = (iconv_t)-1;          static iconv_t iconv_h = (iconv_t) - 1;
177          char   *pin = string, *pout;          char *pin = string, *pout = (char *) s->p;
 #ifdef B_ENDIAN  
         char ss[4096];  // FIXME: global MAX_BUF_SIZE macro need  
   
         pout = ss;  
 #else  
         pout = s->p;  
 #endif  
178    
179          memset(pout, 0, len + 4);          memset(pout, 0, len + 4);
180    
181          if (iconv_h == (iconv_t)-1)          if (g_iconv_works)
182          {          {
183                  size_t i = 1, o = 4;                  if (iconv_h == (iconv_t) - 1)
                 if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t)-1)  
184                  {                  {
185                          printf("rdp_out_unistr: iconv_open[%s -> %s] fail %d\n",                          size_t i = 1, o = 4;
186                                  g_codepage, WINDOWS_CODEPAGE, (int)iconv_h);                          if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t) - 1)
187                          return;                          {
188                                    warning("rdp_out_unistr: iconv_open[%s -> %s] fail %p\n",
189                                            g_codepage, WINDOWS_CODEPAGE, iconv_h);
190    
191                                    g_iconv_works = False;
192                                    rdp_out_unistr(s, string, len);
193                                    return;
194                            }
195                            if (iconv(iconv_h, (ICONV_CONST char **) &pin, &i, &pout, &o) ==
196                                (size_t) - 1)
197                            {
198                                    iconv_close(iconv_h);
199                                    iconv_h = (iconv_t) - 1;
200                                    warning("rdp_out_unistr: iconv(1) fail, errno %d\n", errno);
201    
202                                    g_iconv_works = False;
203                                    rdp_out_unistr(s, string, len);
204                                    return;
205                            }
206                            pin = string;
207                            pout = (char *) s->p;
208                  }                  }
209                  if (iconv(iconv_h, (ICONV_CONST char**)&pin, &i, &pout, &o) == (size_t)-1)  
210                    if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
211                  {                  {
212                          iconv_close(iconv_h);                          iconv_close(iconv_h);
213                          iconv_h = (iconv_t)-1;                          iconv_h = (iconv_t) - 1;
214                          printf("rdp_out_unistr: iconv(1) fail, errno %d\n", errno);                          warning("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);
215    
216                            g_iconv_works = False;
217                            rdp_out_unistr(s, string, len);
218                          return;                          return;
219                  }                  }
                 pin = string; pout = s->p;  
         }  
220    
221          if (iconv(iconv_h, (ICONV_CONST char**)&pin, &ibl, &pout, &obl) == (size_t)-1)                  s->p += len + 2;
         {  
                 iconv_close(iconv_h);  
                 iconv_h = (iconv_t)-1;  
                 printf("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);  
                 return;  
         }  
222    
223  #ifdef B_ENDIAN          }
224          swab(ss, s->p, len + 4);          else
225  #endif  #endif
226            {
227                    int i = 0, j = 0;
228    
229          s->p += len + 2;                  len += 2;
   
 #else /*HAVE_ICONV undef*/  
         int i = 0, j = 0;  
230    
231          len += 2;                  while (i < len)
232                    {
233                            s->p[i++] = string[j++];
234                            s->p[i++] = 0;
235                    }
236    
237          while (i < len)                  s->p += len;
         {  
                 s->p[i++] = string[j++];  
                 s->p[i++] = 0;  
238          }          }
           
         s->p += len;  
 #endif  
239  }  }
240    
241  /* Input a string in Unicode  /* Input a string in Unicode
# Line 225  rdp_in_unistr(STREAM s, char *string, in Line 247  rdp_in_unistr(STREAM s, char *string, in
247  {  {
248  #ifdef HAVE_ICONV  #ifdef HAVE_ICONV
249          size_t ibl = uni_len, obl = uni_len;          size_t ibl = uni_len, obl = uni_len;
250          char *pin, *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;
 #ifdef B_ENDIAN  
         char ss[4096];  // FIXME: global MAX_BUF_SIZE macro need  
   
         swab(s->p, ss, uni_len);  
         pin = ss;  
 #else  
         pin = s->p;  
 #endif  
252    
253          if (iconv_h == (iconv_t)-1)          if (g_iconv_works)
254          {          {
255                  if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t)-1)                  if (iconv_h == (iconv_t) - 1)
256                  {                  {
257                          printf("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",                          if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)
258                                  WINDOWS_CODEPAGE, g_codepage, (int)iconv_h);                          {
259                          return 0;                                  warning("rdp_in_unistr: iconv_open[%s -> %s] fail %p\n",
260                                            WINDOWS_CODEPAGE, g_codepage, iconv_h);
261    
262                                    g_iconv_works = False;
263                                    return rdp_in_unistr(s, string, uni_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);                          iconv_close(iconv_h);
270                  iconv_h = (iconv_t)-1;                          iconv_h = (iconv_t) - 1;
271                  printf("rdp_in_unistr: iconv fail, errno %d\n", errno);                          warning("rdp_in_unistr: iconv fail, errno %d\n", errno);
                 return 0;  
         }  
         return pout - string;  
 #else /* HAVE_ICONV undef */  
         int i = 0;  
272    
273          while (i < uni_len / 2)                          g_iconv_works = False;
274          {                          return rdp_in_unistr(s, string, uni_len);
275                  in_uint8a(s, &string[i++], 1);                  }
276                  in_uint8s(s, 1);  
277          }                  /* we must update the location of the current STREAM for future reads of s->p */
278                    s->p += uni_len;
279    
280          return i - 1;                  return pout - string;
281            }
282            else
283  #endif  #endif
284            {
285                    int i = 0;
286    
287                    while (i < uni_len / 2)
288                    {
289                            in_uint8a(s, &string[i++], 1);
290                            in_uint8s(s, 1);
291                    }
292    
293                    return i - 1;
294            }
295  }  }
296    
297    
# Line 287  rdp_send_logon_info(uint32 flags, char * Line 314  rdp_send_logon_info(uint32 flags, char *
314          time_t t = time(NULL);          time_t t = time(NULL);
315          time_t tzone;          time_t tzone;
316    
 #if 0  
         /* enable rdp compression */  
         /* some problems still exist with rdp5 */  
         flags |= RDP_COMPRESSION;  
 #endif  
   
317          if (!g_use_rdp5 || 1 == g_server_rdp_version)          if (!g_use_rdp5 || 1 == g_server_rdp_version)
318          {          {
319                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));                  DEBUG_RDP5(("Sending RDP4-style Logon packet\n"));
# Line 477  rdp_send_input(uint32 time, uint16 messa Line 498  rdp_send_input(uint32 time, uint16 messa
498          rdp_send_data(s, RDP_DATA_PDU_INPUT);          rdp_send_data(s, RDP_DATA_PDU_INPUT);
499  }  }
500    
501  /* Inform the server on the contents of the persistent bitmap cache */  /* Send a client window information PDU */
502    void
503    rdp_send_client_window_status(int status)
504    {
505            STREAM s;
506            static int current_status = 1;
507    
508            if (current_status == status)
509                    return;
510    
511            s = rdp_init_data(12);
512    
513            out_uint32_le(s, status);
514    
515            switch (status)
516            {
517                    case 0: /* shut the server up */
518                            break;
519    
520                    case 1: /* receive data again */
521                            out_uint32_le(s, 0);    /* unknown */
522                            out_uint16_le(s, g_width);
523                            out_uint16_le(s, g_height);
524                            break;
525            }
526    
527            s_mark_end(s);
528            rdp_send_data(s, RDP_DATA_PDU_CLIENT_WINDOW_STATUS);
529            current_status = status;
530    }
531    
532    /* Send persistent bitmap cache enumeration PDU's */
533  static void  static void
534  rdp_enum_bmpcache2(void)  rdp_enum_bmpcache2(void)
535  {  {
# Line 571  rdp_out_bitmap_caps(STREAM s) Line 623  rdp_out_bitmap_caps(STREAM s)
623          out_uint16_le(s, RDP_CAPSET_BITMAP);          out_uint16_le(s, RDP_CAPSET_BITMAP);
624          out_uint16_le(s, RDP_CAPLEN_BITMAP);          out_uint16_le(s, RDP_CAPLEN_BITMAP);
625    
626          out_uint16_le(s, g_server_bpp); /* Preferred BPP */          out_uint16_le(s, g_server_depth);       /* Preferred colour depth */
627          out_uint16_le(s, 1);    /* Receive 1 BPP */          out_uint16_le(s, 1);    /* Receive 1 BPP */
628          out_uint16_le(s, 1);    /* Receive 4 BPP */          out_uint16_le(s, 1);    /* Receive 4 BPP */
629          out_uint16_le(s, 1);    /* Receive 8 BPP */          out_uint16_le(s, 1);    /* Receive 8 BPP */
# Line 635  rdp_out_bmpcache_caps(STREAM s) Line 687  rdp_out_bmpcache_caps(STREAM s)
687          out_uint16_le(s, RDP_CAPSET_BMPCACHE);          out_uint16_le(s, RDP_CAPSET_BMPCACHE);
688          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);          out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
689    
690          Bpp = (g_server_bpp + 7) / 8;          Bpp = (g_server_depth + 7) / 8; /* bytes per pixel */
691          out_uint8s(s, 24);      /* unused */          out_uint8s(s, 24);      /* unused */
692          out_uint16_le(s, 0x258);        /* entries */          out_uint16_le(s, 0x258);        /* entries */
693          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */          out_uint16_le(s, 0x100 * Bpp);  /* max cell size */
# Line 654  rdp_out_bmpcache2_caps(STREAM s) Line 706  rdp_out_bmpcache2_caps(STREAM s)
706    
707          out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */          out_uint16_le(s, g_bitmap_cache_persist_enable ? 2 : 0);        /* version */
708    
709          out_uint16_le(s, 0x0300);       /* flags? number of caches? */          out_uint16_be(s, 3);    /* number of caches in this set */
710    
711            /* max cell size for cache 0 is 16x16, 1 = 32x32, 2 = 64x64, etc */
712          out_uint32_le(s, BMPCACHE2_C0_CELLS);          out_uint32_le(s, BMPCACHE2_C0_CELLS);
713          out_uint32_le(s, BMPCACHE2_C1_CELLS);          out_uint32_le(s, BMPCACHE2_C1_CELLS);
714          if (pstcache_init(2))          if (pstcache_init(2))
# Line 831  rdp_process_general_caps(STREAM s) Line 884  rdp_process_general_caps(STREAM s)
884  static void  static void
885  rdp_process_bitmap_caps(STREAM s)  rdp_process_bitmap_caps(STREAM s)
886  {  {
887          uint16 width, height, bpp;          uint16 width, height, depth;
888    
889          in_uint16_le(s, bpp);          in_uint16_le(s, depth);
890          in_uint8s(s, 6);          in_uint8s(s, 6);
891    
892          in_uint16_le(s, width);          in_uint16_le(s, width);
893          in_uint16_le(s, height);          in_uint16_le(s, height);
894    
895          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));
896    
897          /*          /*
898           * 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
899           * example when shadowing another session).           * example when shadowing another session).
900           */           */
901          if (g_server_bpp != bpp)          if (g_server_depth != depth)
902          {          {
903                  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",
904                  g_server_bpp = bpp;                          g_server_depth, depth);
905                    g_server_depth = depth;
906          }          }
907          if (g_width != width || g_height != height)          if (g_width != width || g_height != height)
908          {          {
909                  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,
910                          width, height);                          width, height);
911                  g_width = width;                  g_width = width;
912                  g_height = height;                  g_height = height;
# Line 861  rdp_process_bitmap_caps(STREAM s) Line 915  rdp_process_bitmap_caps(STREAM s)
915  }  }
916    
917  /* Process server capabilities */  /* Process server capabilities */
918  void  static void
919  rdp_process_server_caps(STREAM s, uint16 length)  rdp_process_server_caps(STREAM s, uint16 length)
920  {  {
921          int n;          int n;
# Line 920  process_demand_active(STREAM s) Line 974  process_demand_active(STREAM s)
974          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */          rdp_recv(&type);        /* RDP_PDU_SYNCHRONIZE */
975          rdp_recv(&type);        /* RDP_CTL_COOPERATE */          rdp_recv(&type);        /* RDP_CTL_COOPERATE */
976          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */          rdp_recv(&type);        /* RDP_CTL_GRANT_CONTROL */
977          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);          rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0,
978                           g_numlock_sync ? ui_get_numlock_state(read_keyboard_state()) : 0, 0);
979    
980          if (g_use_rdp5)          if (g_use_rdp5)
981          {          {
# Line 943  process_colour_pointer_pdu(STREAM s) Line 998  process_colour_pointer_pdu(STREAM s)
998  {  {
999          uint16 x, y, width, height, cache_idx, masklen, datalen;          uint16 x, y, width, height, cache_idx, masklen, datalen;
1000          uint8 *mask, *data;          uint8 *mask, *data;
1001          HCURSOR cursor;          RD_HCURSOR cursor;
1002    
1003          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
1004          in_uint16_le(s, x);          in_uint16_le(s, x);
# Line 1100  process_palette(STREAM s) Line 1155  process_palette(STREAM s)
1155  {  {
1156          COLOURENTRY *entry;          COLOURENTRY *entry;
1157          COLOURMAP map;          COLOURMAP map;
1158          HCOLOURMAP hmap;          RD_HCOLOURMAP hmap;
1159          int i;          int i;
1160    
1161          in_uint8s(s, 2);        /* pad */          in_uint8s(s, 2);        /* pad */
# Line 1170  process_disconnect_pdu(STREAM s, uint32 Line 1225  process_disconnect_pdu(STREAM s, uint32
1225  }  }
1226    
1227  /* Process data PDU */  /* Process data PDU */
1228  static BOOL  static RD_BOOL
1229  process_data_pdu(STREAM s, uint32 * ext_disc_reason)  process_data_pdu(STREAM s, uint32 * ext_disc_reason)
1230  {  {
1231          uint8 data_pdu_type;          uint8 data_pdu_type;
# Line 1196  process_data_pdu(STREAM s, uint32 * ext_ Line 1251  process_data_pdu(STREAM s, uint32 * ext_
1251                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)                  if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)
1252                          error("error while decompressing packet\n");                          error("error while decompressing packet\n");
1253    
1254                  //len -= 18;                  /* len -= 18; */
1255    
1256                  /* allocate memory and copy the uncompressed data into the temporary stream */                  /* allocate memory and copy the uncompressed data into the temporary stream */
1257                  ns->data = (uint8 *) xrealloc(ns->data, rlen);                  ns->data = (uint8 *) xrealloc(ns->data, rlen);
# Line 1240  process_data_pdu(STREAM s, uint32 * ext_ Line 1295  process_data_pdu(STREAM s, uint32 * ext_
1295    
1296                  case RDP_DATA_PDU_DISCONNECT:                  case RDP_DATA_PDU_DISCONNECT:
1297                          process_disconnect_pdu(s, ext_disc_reason);                          process_disconnect_pdu(s, ext_disc_reason);
1298                          return True;  
1299                            /* We used to return true and disconnect immediately here, but
1300                             * Windows Vista sends a disconnect PDU with reason 0 when
1301                             * reconnecting to a disconnected session, and MSTSC doesn't
1302                             * drop the connection.  I think we should just save the status.
1303                             */
1304                            break;
1305    
1306                  default:                  default:
1307                          unimpl("data PDU %d\n", data_pdu_type);                          unimpl("data PDU %d\n", data_pdu_type);
# Line 1248  process_data_pdu(STREAM s, uint32 * ext_ Line 1309  process_data_pdu(STREAM s, uint32 * ext_
1309          return False;          return False;
1310  }  }
1311    
1312    /* Process redirect PDU from Session Directory */
1313    static RD_BOOL
1314    process_redirect_pdu(STREAM s /*, uint32 * ext_disc_reason */ )
1315    {
1316            uint32 len;
1317    
1318            /* these 2 bytes are unknown, seem to be zeros */
1319            in_uint8s(s, 2);
1320    
1321            /* read connection flags */
1322            in_uint32_le(s, g_redirect_flags);
1323    
1324            /* read length of ip string */
1325            in_uint32_le(s, len);
1326    
1327            /* read ip string */
1328            rdp_in_unistr(s, g_redirect_server, len);
1329    
1330            /* read length of cookie string */
1331            in_uint32_le(s, len);
1332    
1333            /* read cookie string (plain ASCII) */
1334            in_uint8a(s, g_redirect_cookie, len);
1335            g_redirect_cookie[len] = 0;
1336    
1337            /* read length of username string */
1338            in_uint32_le(s, len);
1339    
1340            /* read username string */
1341            rdp_in_unistr(s, g_redirect_username, len);
1342    
1343            /* read length of domain string */
1344            in_uint32_le(s, len);
1345    
1346            /* read domain string */
1347            rdp_in_unistr(s, g_redirect_domain, len);
1348    
1349            /* read length of password string */
1350            in_uint32_le(s, len);
1351    
1352            /* read password string */
1353            rdp_in_unistr(s, g_redirect_password, len);
1354    
1355            g_redirect = True;
1356    
1357            return True;
1358    }
1359    
1360  /* Process incoming packets */  /* Process incoming packets */
1361  /* nevers gets out of here till app is done */  /* nevers gets out of here till app is done */
1362  void  void
1363  rdp_main_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_main_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason)
1364  {  {
1365          while (rdp_loop(deactivated, ext_disc_reason))          while (rdp_loop(deactivated, ext_disc_reason))
1366                  ;                  ;
1367  }  }
1368    
1369  /* used in uiports and rdp_main_loop, processes the rdp packets waiting */  /* used in uiports and rdp_main_loop, processes the rdp packets waiting */
1370  BOOL  RD_BOOL
1371  rdp_loop(BOOL * deactivated, uint32 * ext_disc_reason)  rdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason)
1372  {  {
1373          uint8 type;          uint8 type;
1374          BOOL disc = False;      /* True when a disconnect PDU was received */          RD_BOOL disc = False;   /* True when a disconnect PDU was received */
1375          BOOL cont = True;          RD_BOOL cont = True;
1376          STREAM s;          STREAM s;
1377    
1378          while (cont)          while (cont)
# Line 1281  rdp_loop(BOOL * deactivated, uint32 * ex Line 1390  rdp_loop(BOOL * deactivated, uint32 * ex
1390                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));                                  DEBUG(("RDP_PDU_DEACTIVATE\n"));
1391                                  *deactivated = True;                                  *deactivated = True;
1392                                  break;                                  break;
1393                            case RDP_PDU_REDIRECT:
1394                                    return process_redirect_pdu(s);
1395                                    break;
1396                          case RDP_PDU_DATA:                          case RDP_PDU_DATA:
1397                                  disc = process_data_pdu(s, ext_disc_reason);                                  disc = process_data_pdu(s, ext_disc_reason);
1398                                  break;                                  break;
# Line 1297  rdp_loop(BOOL * deactivated, uint32 * ex Line 1409  rdp_loop(BOOL * deactivated, uint32 * ex
1409  }  }
1410    
1411  /* Establish a connection up to the RDP layer */  /* Establish a connection up to the RDP layer */
1412  BOOL  RD_BOOL
1413  rdp_connect(char *server, uint32 flags, char *domain, char *password,  rdp_connect(char *server, uint32 flags, char *domain, char *password,
1414              char *command, char *directory)              char *command, char *directory)
1415  {  {
# Line 1308  rdp_connect(char *server, uint32 flags, Line 1420  rdp_connect(char *server, uint32 flags,
1420          return True;          return True;
1421  }  }
1422    
1423    /* Establish a reconnection up to the RDP layer */
1424    RD_BOOL
1425    rdp_reconnect(char *server, uint32 flags, char *domain, char *password,
1426                  char *command, char *directory, char *cookie)
1427    {
1428            if (!sec_reconnect(server))
1429                    return False;
1430    
1431            rdp_send_logon_info(flags, domain, g_username, password, command, directory);
1432            return True;
1433    }
1434    
1435    /* Called during redirection to reset the state to support redirection */
1436    void
1437    rdp_reset_state(void)
1438    {
1439            g_next_packet = NULL;   /* reset the packet information */
1440            g_rdp_shareid = 0;
1441            sec_reset_state();
1442    }
1443    
1444  /* Disconnect from the RDP layer */  /* Disconnect from the RDP layer */
1445  void  void
1446  rdp_disconnect(void)  rdp_disconnect(void)
Legend:
Removed from v.858  
changed lines
  Added in v.1372
  ViewVC Help
Powered by ViewVC 1.1.26