/[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 21 by matty, Mon Oct 16 08:44:48 2000 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 <unistd.h>     /* read close getuid getgid getpid getppid gethostname */  #include <stdarg.h>             /* va_list va_start va_end */
23  #include <fcntl.h>      /* open */  #include <unistd.h>             /* read close getuid getgid getpid getppid gethostname */
24  #include <pwd.h>        /* getpwuid */  #include <fcntl.h>              /* open */
25  #include <sys/stat.h>   /* stat */  #include <pwd.h>                /* getpwuid */
26  #include <sys/time.h>   /* gettimeofday */  #include <limits.h>             /* PATH_MAX */
27  #include <sys/times.h>  /* times */  #include <sys/stat.h>           /* stat */
28    #include <sys/time.h>           /* gettimeofday */
29    #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  BOOL motion = True;  int height;
39    int tcp_port_rdp = TCP_PORT_RDP;
40    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 usage(char *program)  static void
51    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 main(int argc, char *argv[])  int
74    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". Copyright (C) 1999-2000 Matt Chapman.\n");          printf("Version " VERSION ". Copyright (C) 1999-2001 Matt Chapman.\n");
89          STATUS("See http://www.rdesktop.org/ for more information.\n\n");          printf("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));
                                 break;  
   
                         case 'p':  
                                 flags |= RDP_LOGON_AUTO;  
                                 strncpy(password, optarg, sizeof(password));  
105                                  break;                                  break;
106    
107                          case 's':                          case 's':
108                                  strncpy(shell, optarg, sizeof(shell));                                  STRNCPY(shell, optarg, sizeof(shell));
109                                  break;                                  break;
110    
111                          case 'c':                          case 'c':
112                                  strncpy(directory, optarg, sizeof(directory));                                  STRNCPY(directory, optarg, sizeof(directory));
113                                  break;                                  break;
114    
115                          case 'n':                          case 'p':
116                                  strncpy(hostname, optarg, sizeof(hostname));                                  STRNCPY(password, optarg, sizeof(password));
117                                    flags |= RDP_LOGON_AUTO;
118                                  break;                                  break;
119    
120                          case 'w':                          case 'P':
121                                  width = strtol(optarg, NULL, 10);                                  askpass_result = askpass(optarg, "Enter password");
122                                    if (askpass_result == NULL)
123                                            exit(1);
124    
125                                    STRNCPY(password, askpass_result, sizeof(password));
126                                    free(askpass_result);
127                                    flags |= RDP_LOGON_AUTO;
128                                  break;                                  break;
129    
130                          case 'h':                          case 'n':
131                                  height = strtol(optarg, NULL, 10);                                  STRNCPY(hostname, optarg, sizeof(hostname));
132                                  break;                                  break;
133    
134                          case 'k':                          case 'k':
135                                  keylayout = strtol(optarg, NULL, 16);                                  STRNCPY(keymapname, optarg, sizeof(keymapname));
136                                  break;                                  break;
137    
138                          case 'm':                          case 'g':
139                                  motion = False;                                  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                                            error("invalid geometry\n");
146                                            return 1;
147                                    }
148                                    break;
149    
150                            case 'f':
151                                    fullscreen = True;
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 't':
171                                    tcp_port_rdp = strtol(optarg, NULL, 10);
172                                    break;
173    
174                            case 'K':
175                                    grab_keyboard = False;
176                                    break;
177    
178                            case 'h':
179                          case '?':                          case '?':
180                          default:                          default:
181                                  usage(argv[0]);                                  usage(argv[0]);
# Line 147  int main(int argc, char *argv[]) Line 196  int 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          if (!rdp_connect(server, flags, domain, password, shell, directory))          if (!strcmp(password, "-"))
222                  return 1;          {
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          STATUS("Connection successful.\n");          if ((width == 0) || (height == 0))
233            {
234                    width = 800;
235                    height = 600;
236            }
237    
238          strcpy(title, "rdesktop - ");          strcpy(title, "rdesktop - ");
239          strncat(title, server, sizeof(title));          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            printf("Connection successful.\n");
249    
250          if (ui_create_window(title))          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 generate_random(uint8 *random)  void
263    generate_random(uint8 * random)
264  {  {
265          struct stat st;          struct stat st;
266          uint32 *r = (uint32 *)random;          struct tms tmsbuf;
267            uint32 *r = (uint32 *) 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 199  void generate_random(uint8 *random) Line 279  void generate_random(uint8 *random)
279          /* Otherwise use whatever entropy we can gather - ideas welcome. */          /* Otherwise use whatever entropy we can gather - ideas welcome. */
280          r[0] = (getpid()) | (getppid() << 16);          r[0] = (getpid()) | (getppid() << 16);
281          r[1] = (getuid()) | (getgid() << 16);          r[1] = (getuid()) | (getgid() << 16);
282          r[2] = times(NULL); /* system uptime (clocks) */          r[2] = times(&tmsbuf);  /* system uptime (clocks) */
283          gettimeofday((struct timeval *)&r[3], NULL); /* sec and usec */          gettimeofday((struct timeval *) &r[3], NULL);   /* sec and usec */
284          stat("/tmp", &st);          stat("/tmp", &st);
285          r[5] = st.st_atime;          r[5] = st.st_atime;
286          r[6] = st.st_mtime;          r[6] = st.st_mtime;
# Line 208  void generate_random(uint8 *random) Line 288  void generate_random(uint8 *random)
288  }  }
289    
290  /* malloc; exit if out of memory */  /* malloc; exit if out of memory */
291  void *xmalloc(int size)  void *
292    xmalloc(int size)
293  {  {
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;
301  }  }
302    
303  /* realloc; exit if out of memory */  /* realloc; exit if out of memory */
304  void *xrealloc(void *oldmem, int size)  void *
305    xrealloc(void *oldmem, int size)
306  {  {
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;
314  }  }
315    
316  /* free */  /* free */
317  void xfree(void *mem)  void
318    xfree(void *mem)
319  {  {
320          free(mem);          free(mem);
321  }  }
322    
323  /* Produce a hex dump */  /* report an error */
324  void hexdump(unsigned char *p, unsigned int len)  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
351    hexdump(unsigned char *p, unsigned int len)
352  {  {
353          unsigned char *line = p;          unsigned char *line = p;
354          unsigned int thisline, offset = 0;          unsigned int thisline, offset = 0;
# Line 246  void hexdump(unsigned char *p, unsigned Line 356  void hexdump(unsigned char *p, unsigned
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])                          printf("%02x ", line[i]);
366    
367                  for (; i < 16; i++)                  for (; i < 16; i++)
368                          STATUS("   ");                          printf("   ");
369    
370                  for (i = 0; i < thisline; i++)                  for (i = 0; i < thisline; i++)
371                          STATUS("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.');                          printf("%c", (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.21  
changed lines
  Added in v.100
  ViewVC Help
Powered by ViewVC 1.1.26