/[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 29 by matty, Fri Sep 14 03:38:39 2001 UTC revision 103 by matthewc, Thu Aug 29 14:18:24 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 sendmotion = 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;
46  BOOL fullscreen = False;  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);          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:g:k:mbleKFVh?")) != -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;                                  break;
133    
134                            case 'k':
135                                    STRNCPY(keymapname, optarg, sizeof(keymapname));
136                                    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':  
                                 sendmotion = 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 'F':                          case 'K':
175                                  fullscreen = True;                                  grab_keyboard = False;
176                                  break;                                  break;
177    
178                          case 'h':                          case 'h':
# Line 172  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            else
238            {
239                    /* make sure width is a multiple of 4 */
240                    width = (width + 3) & ~3;
241            }
242    
243            strcpy(title, "rdesktop - ");
244            strncat(title, server, sizeof(title) - sizeof("rdesktop - "));
245    
246            xkeymap_init1();
247            if (!ui_init())
248                    return 1;
249    
250                  STATUS("Connection successful.\n");          if (!rdp_connect(server, flags, domain, password, shell, directory))
251                    return 1;
252    
253            printf("Connection successful.\n");
254    
255            if (ui_create_window())
256            {
257                  rdp_main_loop();                  rdp_main_loop();
258                  ui_destroy_window();                  ui_destroy_window();
259          }          }
260    
261            printf("Disconnecting...\n");
262          rdp_disconnect();          rdp_disconnect();
263          return 0;          return 0;
264  }  }
265    
266  /* Generate a 32-byte random for the secure transport code. */  /* Generate a 32-byte random for the secure transport code. */
267  void  void
268  generate_random(uint8 *random)  generate_random(uint8 * random)
269  {  {
270          struct stat st;          struct stat st;
271          struct tms tmsbuf;          struct tms tmsbuf;
# Line 216  generate_random(uint8 *random) Line 273  generate_random(uint8 *random)
273          int fd;          int fd;
274    
275          /* If we have a kernel random device, use it. */          /* If we have a kernel random device, use it. */
276          if ((fd = open("/dev/urandom", O_RDONLY)) != -1)          if (((fd = open("/dev/urandom", O_RDONLY)) != -1)
277                || ((fd = open("/dev/random", O_RDONLY)) != -1))
278          {          {
279                  read(fd, random, 32);                  read(fd, random, 32);
280                  close(fd);                  close(fd);
# Line 241  xmalloc(int size) Line 299  xmalloc(int size)
299          void *mem = malloc(size);          void *mem = malloc(size);
300          if (mem == NULL)          if (mem == NULL)
301          {          {
302                  ERROR("xmalloc %d\n", size);                  error("xmalloc %d\n", size);
303                  exit(1);                  exit(1);
304          }          }
305          return mem;          return mem;
# Line 254  xrealloc(void *oldmem, int size) Line 312  xrealloc(void *oldmem, int size)
312          void *mem = realloc(oldmem, size);          void *mem = realloc(oldmem, size);
313          if (mem == NULL)          if (mem == NULL)
314          {          {
315                  ERROR("xrealloc %d\n", size);                  error("xrealloc %d\n", size);
316                  exit(1);                  exit(1);
317          }          }
318          return mem;          return mem;
# Line 267  xfree(void *mem) Line 325  xfree(void *mem)
325          free(mem);          free(mem);
326  }  }
327    
328  /* Produce a hex dump */  /* report an error */
329    void
330    error(char *format, ...)
331    {
332            va_list ap;
333    
334            fprintf(stderr, "ERROR: ");
335    
336            va_start(ap, format);
337            vfprintf(stderr, format, ap);
338            va_end(ap);
339    }
340    
341    /* report an unimplemented protocol feature */
342    void
343    unimpl(char *format, ...)
344    {
345            va_list ap;
346    
347            fprintf(stderr, "NOT IMPLEMENTED: ");
348    
349            va_start(ap, format);
350            vfprintf(stderr, format, ap);
351            va_end(ap);
352    }
353    
354    /* produce a hex dump */
355  void  void
356  hexdump(unsigned char *p, unsigned int len)  hexdump(unsigned char *p, unsigned int len)
357  {  {
# Line 277  hexdump(unsigned char *p, unsigned int l Line 361  hexdump(unsigned char *p, unsigned int l
361    
362          while (offset < len)          while (offset < len)
363          {          {
364                  STATUS("%04x ", offset);                  printf("%04x ", offset);
365                  thisline = len - offset;                  thisline = len - offset;
366                  if (thisline > 16)                  if (thisline > 16)
367                          thisline = 16;                          thisline = 16;
368    
369                  for (i = 0; i < thisline; i++)                  for (i = 0; i < thisline; i++)
370                          STATUS("%02x ", line[i]) for (; i < 16; i++)                          printf("%02x ", line[i]);
371                                  STATUS("   ");  
372                    for (; i < 16; i++)
373                            printf("   ");
374    
375                  for (i = 0; i < thisline; i++)                  for (i = 0; i < thisline; i++)
376                          STATUS("%c",                          printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.');
                                (line[i] >= 0x20  
                                 && line[i] < 0x7f) ? line[i] : '.');  
377    
378                  STATUS("\n");                  printf("\n");
379                  offset += thisline;                  offset += thisline;
380                  line += thisline;                  line += thisline;
381          }          }
382  }  }
383    
384    int
385    load_licence(unsigned char **data)
386    {
387            char path[PATH_MAX];
388            char *home;
389            struct stat st;
390            int fd;
391    
392            home = getenv("HOME");
393            if (home == NULL)
394                    return -1;
395    
396            STRNCPY(path, home, sizeof(path));
397            strncat(path, "/.rdesktop/licence", sizeof(path) - strlen(path) - 1);
398    
399            fd = open(path, O_RDONLY);
400            if (fd == -1)
401                    return -1;
402    
403            if (fstat(fd, &st))
404                    return -1;
405    
406            *data = xmalloc(st.st_size);
407            return read(fd, *data, st.st_size);
408    }
409    
410    void
411    save_licence(unsigned char *data, int length)
412    {
413            char path[PATH_MAX];
414            char *home;
415            int fd;
416    
417            home = getenv("HOME");
418            if (home == NULL)
419                    return;
420    
421            STRNCPY(path, home, sizeof(path));
422            strncat(path, "/.rdesktop", sizeof(path) - strlen(path) - 1);
423            mkdir(path, 0700);
424    
425            strncat(path, "/licence", sizeof(path) - strlen(path) - 1);
426    
427            fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
428            if (fd == -1)
429            {
430                    perror("open");
431                    return;
432            }
433    
434            write(fd, data, length);
435            close(fd);
436    }
Legend:
Removed from v.29  
changed lines
  Added in v.103
  ViewVC Help
Powered by ViewVC 1.1.26