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

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

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