/[rdesktop]/sourceforge.net/branches/seamlessrdp-branch/rdesktop/rdesktop.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/branches/seamlessrdp-branch/rdesktop/rdesktop.c

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

revision 25 by matty, Sat Jan 6 03:47:04 2001 UTC revision 169 by matthewc, Tue Sep 17 07:27:49 2002 UTC
# Line 1  Line 1 
1  /*  /*
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     Entrypoint and utility functions     Entrypoint and utility functions
4     Copyright (C) Matthew Chapman 1999-2000     Copyright (C) Matthew Chapman 1999-2002
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
8     the Free Software Foundation; either version 2 of the License, or     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.     (at your option) any later version.
10      
11     This program is distributed in the hope that it will be useful,     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.     GNU General Public License for more details.
15      
16     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */  */
20    
21  #include <stdlib.h>             /* malloc realloc free */  #include <stdlib.h>             /* malloc realloc free */
22    #include <stdarg.h>             /* va_list va_start va_end */
23  #include <unistd.h>             /* read close getuid getgid getpid getppid gethostname */  #include <unistd.h>             /* read close getuid getgid getpid getppid gethostname */
24  #include <fcntl.h>              /* open */  #include <fcntl.h>              /* open */
25  #include <pwd.h>                /* getpwuid */  #include <pwd.h>                /* getpwuid */
26    #include <limits.h>             /* PATH_MAX */
27  #include <sys/stat.h>           /* stat */  #include <sys/stat.h>           /* stat */
28  #include <sys/time.h>           /* gettimeofday */  #include <sys/time.h>           /* gettimeofday */
29  #include <sys/times.h>          /* times */  #include <sys/times.h>          /* times */
30  #include "rdesktop.h"  #include "rdesktop.h"
31    
32    char title[32] = "";
33  char username[16];  char username[16];
34  char hostname[16];  char hostname[16];
35    char keymapname[16];
36    int keylayout = 0x409;          /* Defaults to US keyboard layout */
37  int width = 800;  int width = 800;
38  int height = 600;  int height = 600;
39  int keylayout = 0x409;  int tcp_port_rdp = TCP_PORT_RDP;
40  BOOL motion = True;  BOOL bitmap_compression = True;
41    BOOL sendmotion = True;
42  BOOL orders = True;  BOOL orders = True;
43  BOOL licence = True;  BOOL licence = True;
44    BOOL encryption = True;
45    BOOL desktop_save = True;
46    BOOL fullscreen = False;
47    BOOL grab_keyboard = True;
48    
49  /* Display usage information */  /* Display usage information */
50  static void  static void
51  usage(char *program)  usage(char *program)
52  {  {
53          STATUS("Usage: %s [options] server\n", program);          fprintf(stderr, "rdesktop: A Remote Desktop Protocol client.\n");
54          STATUS("   -u: user name\n");          fprintf(stderr, "Version " VERSION ". Copyright (C) 1999-2002 Matt Chapman.\n");
55          STATUS("   -d: domain\n");          fprintf(stderr, "See http://www.rdesktop.org/ for more information.\n\n");
56          STATUS("   -s: shell\n");  
57          STATUS("   -c: working directory\n");          fprintf(stderr, "Usage: %s [options] server\n", program);
58          STATUS("   -p: password (autologon)\n");          fprintf(stderr, "   -u: user name\n");
59          STATUS("   -n: client hostname\n");          fprintf(stderr, "   -d: domain\n");
60          STATUS("   -w: desktop width\n");          fprintf(stderr, "   -s: shell\n");
61          STATUS("   -h: desktop height\n");          fprintf(stderr, "   -c: working directory\n");
62          STATUS("   -k: keyboard layout (hex)\n");          fprintf(stderr, "   -p: password (autologon)\n");
63          STATUS("   -b: force bitmap updates\n");          fprintf(stderr, "   -P: askpass-program (autologon)\n");
64          STATUS("   -m: do not send motion events\n");          fprintf(stderr, "   -n: client hostname\n");
65          STATUS("   -l: do not request licence\n\n");          fprintf(stderr, "   -k: keyboard layout on terminal server (us,sv,gr etc.)\n");
66            fprintf(stderr, "   -g: desktop geometry (WxH)\n");
67            fprintf(stderr, "   -f: full-screen mode\n");
68            fprintf(stderr, "   -b: force bitmap updates\n");
69            fprintf(stderr, "   -e: disable encryption (French TS)\n");
70            fprintf(stderr, "   -m: do not send motion events\n");
71            fprintf(stderr, "   -l: do not request licence\n");
72            fprintf(stderr, "   -t: rdp tcp port\n");
73            fprintf(stderr, "   -K: keep window manager key bindings\n");
74            fprintf(stderr, "   -w: window title\n");
75  }  }
76    
77  /* Client program */  /* Client program */
78  int  int
79  main(int argc, char *argv[])  main(int argc, char *argv[])
80  {  {
81          struct passwd *pw;          char fullhostname[64];
         char *server;  
         uint32 flags;  
82          char domain[16];          char domain[16];
83          char password[16];          char password[16];
84            char *askpass_result;
85          char shell[32];          char shell[32];
86          char directory[32];          char directory[32];
87          char title[32];          struct passwd *pw;
88            char *server, *p;
89            uint32 flags;
90          int c;          int c;
91    
         STATUS("rdesktop: A Remote Desktop Protocol client.\n");  
         STATUS("Version " VERSION  
                ". Copyright (C) 1999-2000 Matt Chapman.\n");  
         STATUS("See http://www.rdesktop.org/ for more information.\n\n");  
   
92          flags = RDP_LOGON_NORMAL;          flags = RDP_LOGON_NORMAL;
93          domain[0] = password[0] = shell[0] = directory[0] = 0;          domain[0] = password[0] = shell[0] = directory[0] = 0;
94            strcpy(keymapname, "us");
95    
96          while ((c = getopt(argc, argv, "u:d:s:c:p:n:w:h:k:bml?")) != -1)          while ((c = getopt(argc, argv, "u:d:s:c:p:P:n:k:g:t:fbemlKw:h?")) != -1)
97          {          {
98                  switch (c)                  switch (c)
99                  {                  {
100                          case 'u':                          case 'u':
101                                  strncpy(username, optarg, sizeof(username));                                  STRNCPY(username, optarg, sizeof(username));
102                                  break;                                  break;
103    
104                          case 'd':                          case 'd':
105                                  strncpy(domain, optarg, sizeof(domain));                                  STRNCPY(domain, optarg, sizeof(domain));
                                 break;  
   
                         case 'p':  
                                 flags |= RDP_LOGON_AUTO;  
                                 strncpy(password, optarg, sizeof(password));  
106                                  break;                                  break;
107    
108                          case 's':                          case 's':
109                                  strncpy(shell, optarg, sizeof(shell));                                  STRNCPY(shell, optarg, sizeof(shell));
110                                  break;                                  break;
111    
112                          case 'c':                          case 'c':
113                                  strncpy(directory, optarg, sizeof(directory));                                  STRNCPY(directory, optarg, sizeof(directory));
114                                  break;                                  break;
115    
116                          case 'n':                          case 'p':
117                                  strncpy(hostname, optarg, sizeof(hostname));                                  STRNCPY(password, optarg, sizeof(password));
118                                    flags |= RDP_LOGON_AUTO;
119                                  break;                                  break;
120    
121                          case 'w':                          case 'P':
122                                  width = strtol(optarg, NULL, 10);                                  askpass_result = askpass(optarg, "Enter password");
123                                    if (askpass_result == NULL)
124                                            exit(1);
125    
126                                    STRNCPY(password, askpass_result, sizeof(password));
127                                    free(askpass_result);
128                                    flags |= RDP_LOGON_AUTO;
129                                  break;                                  break;
130    
131                          case 'h':                          case 'n':
132                                  height = strtol(optarg, NULL, 10);                                  STRNCPY(hostname, optarg, sizeof(hostname));
133                                  break;                                  break;
134    
135                          case 'k':                          case 'k':
136                                  keylayout = strtol(optarg, NULL, 16);                                  STRNCPY(keymapname, optarg, sizeof(keymapname));
137                                  break;                                  break;
138    
139                          case 'm':                          case 'g':
140                                  motion = False;                                  width = strtol(optarg, &p, 10);
141                                    if (*p == 'x')
142                                            height = strtol(p + 1, NULL, 10);
143    
144                                    if ((width == 0) || (height == 0))
145                                    {
146                                            error("invalid geometry\n");
147                                            return 1;
148                                    }
149                                    break;
150    
151                            case 'f':
152                                    fullscreen = True;
153                                  break;                                  break;
154    
155                          case 'b':                          case 'b':
156                                  orders = False;                                  orders = False;
157                                  break;                                  break;
158    
159                            case 'e':
160                                    encryption = False;
161                                    break;
162    
163                            case 'm':
164                                    sendmotion = False;
165                                    break;
166    
167                          case 'l':                          case 'l':
168                                  licence = False;                                  licence = False;
169                                  break;                                  break;
170    
171                            case 't':
172                                    tcp_port_rdp = strtol(optarg, NULL, 10);
173                                    break;
174    
175                            case 'K':
176                                    grab_keyboard = False;
177                                    break;
178    
179                            case 'w':
180                                    strncpy(title, optarg, sizeof(title));
181                                    break;
182    
183                            case 'h':
184                          case '?':                          case '?':
185                          default:                          default:
186                                  usage(argv[0]);                                  usage(argv[0]);
# Line 150  main(int argc, char *argv[]) Line 201  main(int argc, char *argv[])
201                  pw = getpwuid(getuid());                  pw = getpwuid(getuid());
202                  if ((pw == NULL) || (pw->pw_name == NULL))                  if ((pw == NULL) || (pw->pw_name == NULL))
203                  {                  {
204                          STATUS("Could not determine user name.\n");                          error("could not determine username, use -u\n");
205                          return 1;                          return 1;
206                  }                  }
207    
208                  strncpy(username, pw->pw_name, sizeof(username));                  STRNCPY(username, pw->pw_name, sizeof(username));
209          }          }
210    
211          if (hostname[0] == 0)          if (hostname[0] == 0)
212          {          {
213                  if (gethostname(hostname, sizeof(hostname)) == -1)                  if (gethostname(fullhostname, sizeof(fullhostname)) == -1)
214                  {                  {
215                          STATUS("Could not determine host name.\n");                          error("could not determine local hostname, use -n\n");
216                          return 1;                          return 1;
217                  }                  }
218    
219                    p = strchr(fullhostname, '.');
220                    if (p != NULL)
221                            *p = 0;
222    
223                    STRNCPY(hostname, fullhostname, sizeof(hostname));
224          }          }
225    
226          if (!rdp_connect(server, flags, domain, password, shell, directory))          if (!strcmp(password, "-"))
227            {
228                    p = getpass("Password: ");
229                    if (p == NULL)
230                    {
231                            error("failed to read password\n");
232                            return 0;
233                    }
234                    STRNCPY(password, p, sizeof(password));
235            }
236    
237            if (!strlen(title))
238            {
239                    strcpy(title, "rdesktop - ");
240                    strncat(title, server, sizeof(title) - sizeof("rdesktop - "));
241            }
242    
243            if (!ui_init())
244                  return 1;                  return 1;
245    
246          STATUS("Connection successful.\n");          if (!rdp_connect(server, flags, domain, password, shell, directory))
247                    return 1;
248    
249          strcpy(title, "rdesktop - ");          DEBUG(("Connection successful.\n"));
         strncat(title, server, sizeof(title));  
250    
251          if (ui_create_window(title))          if (ui_create_window())
252          {          {
253                  rdp_main_loop();                  rdp_main_loop();
254                  ui_destroy_window();                  ui_destroy_window();
255          }          }
256    
257            DEBUG(("Disconnecting...\n"));
258          rdp_disconnect();          rdp_disconnect();
259          return 0;          return 0;
260  }  }
261    
262  /* Generate a 32-byte random for the secure transport code. */  /* Generate a 32-byte random for the secure transport code. */
263  void  void
264  generate_random(uint8 *random)  generate_random(uint8 * random)
265  {  {
266          struct stat st;          struct stat st;
267          struct tms tmsbuf;          struct tms tmsbuf;
# Line 194  generate_random(uint8 *random) Line 269  generate_random(uint8 *random)
269          int fd;          int fd;
270    
271          /* If we have a kernel random device, use it. */          /* If we have a kernel random device, use it. */
272          if ((fd = open("/dev/urandom", O_RDONLY)) != -1)          if (((fd = open("/dev/urandom", O_RDONLY)) != -1)
273                || ((fd = open("/dev/random", O_RDONLY)) != -1))
274          {          {
275                  read(fd, random, 32);                  read(fd, random, 32);
276                  close(fd);                  close(fd);
# Line 219  xmalloc(int size) Line 295  xmalloc(int size)
295          void *mem = malloc(size);          void *mem = malloc(size);
296          if (mem == NULL)          if (mem == NULL)
297          {          {
298                  ERROR("xmalloc %d\n", size);                  error("xmalloc %d\n", size);
299                  exit(1);                  exit(1);
300          }          }
301          return mem;          return mem;
# Line 232  xrealloc(void *oldmem, int size) Line 308  xrealloc(void *oldmem, int size)
308          void *mem = realloc(oldmem, size);          void *mem = realloc(oldmem, size);
309          if (mem == NULL)          if (mem == NULL)
310          {          {
311                  ERROR("xrealloc %d\n", size);                  error("xrealloc %d\n", size);
312                  exit(1);                  exit(1);
313          }          }
314          return mem;          return mem;
# Line 245  xfree(void *mem) Line 321  xfree(void *mem)
321          free(mem);          free(mem);
322  }  }
323    
324  /* Produce a hex dump */  /* report an error */
325    void
326    error(char *format, ...)
327    {
328            va_list ap;
329    
330            fprintf(stderr, "ERROR: ");
331    
332            va_start(ap, format);
333            vfprintf(stderr, format, ap);
334            va_end(ap);
335    }
336    
337    /* report an unimplemented protocol feature */
338    void
339    unimpl(char *format, ...)
340    {
341            va_list ap;
342    
343            fprintf(stderr, "NOT IMPLEMENTED: ");
344    
345            va_start(ap, format);
346            vfprintf(stderr, format, ap);
347            va_end(ap);
348    }
349    
350    /* produce a hex dump */
351  void  void
352  hexdump(unsigned char *p, unsigned int len)  hexdump(unsigned char *p, unsigned int len)
353  {  {
# Line 255  hexdump(unsigned char *p, unsigned int l Line 357  hexdump(unsigned char *p, unsigned int l
357    
358          while (offset < len)          while (offset < len)
359          {          {
360                  STATUS("%04x ", offset);                  printf("%04x ", offset);
361                  thisline = len - offset;                  thisline = len - offset;
362                  if (thisline > 16)                  if (thisline > 16)
363                          thisline = 16;                          thisline = 16;
364    
365                  for (i = 0; i < thisline; i++)                  for (i = 0; i < thisline; i++)
366                          STATUS("%02x ", line[i]) for (; i < 16; i++)                          printf("%02x ", line[i]);
367                                  STATUS("   ");  
368                    for (; i < 16; i++)
369                            printf("   ");
370    
371                  for (i = 0; i < thisline; i++)                  for (i = 0; i < thisline; i++)
372                          STATUS("%c",                          printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.');
                                (line[i] >= 0x20  
                                 && line[i] < 0x7f) ? line[i] : '.');  
373    
374                  STATUS("\n");                  printf("\n");
375                  offset += thisline;                  offset += thisline;
376                  line += thisline;                  line += thisline;
377          }          }
378  }  }
379    
380    #ifdef SAVE_LICENCE
381    int
382    load_licence(unsigned char **data)
383    {
384            char path[PATH_MAX];
385            char *home;
386            struct stat st;
387            int fd;
388    
389            home = getenv("HOME");
390            if (home == NULL)
391                    return -1;
392    
393            STRNCPY(path, home, sizeof(path));
394            strncat(path, "/.rdesktop/licence", sizeof(path) - strlen(path) - 1);
395    
396            fd = open(path, O_RDONLY);
397            if (fd == -1)
398                    return -1;
399    
400            if (fstat(fd, &st))
401                    return -1;
402    
403            *data = xmalloc(st.st_size);
404            return read(fd, *data, st.st_size);
405    }
406    
407    void
408    save_licence(unsigned char *data, int length)
409    {
410            char path[PATH_MAX];
411            char *home;
412            int fd;
413    
414            home = getenv("HOME");
415            if (home == NULL)
416                    return;
417    
418            STRNCPY(path, home, sizeof(path));
419            strncat(path, "/.rdesktop", sizeof(path) - strlen(path) - 1);
420            mkdir(path, 0700);
421    
422            strncat(path, "/licence", sizeof(path) - strlen(path) - 1);
423    
424            fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
425            if (fd == -1)
426            {
427                    perror("open");
428                    return;
429            }
430    
431            write(fd, data, length);
432            close(fd);
433    }
434    #endif
Legend:
Removed from v.25  
changed lines
  Added in v.169
  ViewVC Help
Powered by ViewVC 1.1.26