scp.c

   1 /*
   2  *  scp.c  -  Scp (Secure Copy) client for PuTTY.
   3  *  Joris van Rantwijk, Simon Tatham
   4  *
   5  *  This is mainly based on ssh-1.2.26/scp.c by Timo Rinne & Tatu Ylonen.
   6  *  They, in turn, used stuff from BSD rcp.
   7  *
   8  *  Adaptations to enable connecting a GUI by L. Gunnarsson - Sept 2000
   9  */
  10
  11 #include <windows.h>
  12 #ifndef AUTO_WINSOCK
  13 #ifdef WINSOCK_TWO
  14 #include <winsock2.h>
  15 #else
  16 #include <winsock.h>
  17 #endif
  18 #endif
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <time.h>
  23 /* GUI Adaptation - Sept 2000 */
  24 #include <winuser.h>
  25 #include <winbase.h>
  26
  27 #define PUTTY_DO_GLOBALS
  28 #include "putty.h"
  29 #include "winstuff.h"
  30 #include "storage.h"
  31
  32 #define TIME_POSIX_TO_WIN(t, ft) (*(LONGLONG*)&(ft) = \
  33         ((LONGLONG) (t) + (LONGLONG) 11644473600) * (LONGLONG) 10000000)
  34 #define TIME_WIN_TO_POSIX(ft, t) ((t) = (unsigned long) \
  35         ((*(LONGLONG*)&(ft)) / (LONGLONG) 10000000 - (LONGLONG) 11644473600))
  36
  37 /* GUI Adaptation - Sept 2000 */
  38 #define   WM_APP_BASE           0x8000
  39 #define   WM_STD_OUT_CHAR       ( WM_APP_BASE+400 )
  40 #define   WM_STD_ERR_CHAR       ( WM_APP_BASE+401 )
  41 #define   WM_STATS_CHAR         ( WM_APP_BASE+402 )
  42 #define   WM_STATS_SIZE         ( WM_APP_BASE+403 )
  43 #define   WM_STATS_PERCENT      ( WM_APP_BASE+404 )
  44 #define   WM_STATS_ELAPSED      ( WM_APP_BASE+405 )
  45 #define   WM_RET_ERR_CNT        ( WM_APP_BASE+406 )
  46 #define   WM_LS_RET_ERR_CNT     ( WM_APP_BASE+407 )
  47
  48 static int verbose = 0;
  49 static int recursive = 0;
  50 static int preserve = 0;
  51 static int targetshouldbedirectory = 0;
  52 static int statistics = 1;
  53 static int portnumber = 0;
  54 static char *password = NULL;
  55 static int errs = 0;
  56 static int connection_open = 0;
  57 /* GUI Adaptation - Sept 2000 */
  58 #define NAME_STR_MAX 2048
  59 static char statname[NAME_STR_MAX+1];
  60 static unsigned long statsize = 0;
  61 static int statperct = 0;
  62 static time_t statelapsed = 0;
  63 static int gui_mode = 0;
  64 static char *gui_hwnd = NULL;
  65
  66 static void source(char *src);
  67 static void rsource(char *src);
  68 static void sink(char *targ, char *src);
  69 /* GUI Adaptation - Sept 2000 */
  70 static void tell_char(FILE *stream, char c);
  71 static void tell_str(FILE *stream, char *str);
  72 static void tell_user(FILE *stream, char *fmt, ...);
  73 static void send_char_msg(unsigned int msg_id, char c);
  74 static void send_str_msg(unsigned int msg_id, char *str);
  75 static void gui_update_stats(char *name, unsigned long size, int percentage, time_t elapsed);
  76
  77 void begin_session(void) { }
  78 void logevent(char *string) { }
  79
  80 void verify_ssh_host_key(char *host, int port, char *keytype,
  81                          char *keystr, char *fingerprint) {
  82     int ret;
  83
  84     static const char absentmsg[] =
  85         "The server's host key is not cached in the registry. You\n"
  86         "have no guarantee that the server is the computer you\n"
  87         "think it is.\n"
  88         "The server's key fingerprint is:\n"
  89         "%s\n"
  90         "If you trust this host, enter \"y\" to add the key to\n"
  91         "PuTTY's cache and carry on connecting.\n"
  92         "If you do not trust this host, enter \"n\" to abandon the\n"
  93         "connection.\n"
  94         "Continue connecting? (y/n) ";
  95
  96     static const char wrongmsg[] =
  97         "WARNING - POTENTIAL SECURITY BREACH!\n"
  98         "The server's host key does not match the one PuTTY has\n"
  99         "cached in the registry. This means that either the\n"
 100         "server administrator has changed the host key, or you\n"
 101         "have actually connected to another computer pretending\n"
 102         "to be the server.\n"
 103         "The new key fingerprint is:\n"
 104         "%s\n"
 105         "If you were expecting this change and trust the new key,\n"
 106         "enter Yes to update PuTTY's cache and continue connecting.\n"
 107         "If you want to carry on connecting but without updating\n"
 108         "the cache, enter No.\n"
 109         "If you want to abandon the connection completely, press\n"
 110         "Return to cancel. Pressing Return is the ONLY guaranteed\n"
 111         "safe choice.\n"
 112         "Update cached key? (y/n, Return cancels connection) ";
 113
 114     static const char abandoned[] = "Connection abandoned.\n";
 115
 116     char line[32];
 117
 118     /*
 119      * Verify the key against the registry.
 120      */
 121     ret = verify_host_key(host, port, keytype, keystr);
 122
 123     if (ret == 0)                      /* success - key matched OK */
 124         return;
 125     if (ret == 2) {                    /* key was different */
 126         fprintf(stderr, wrongmsg, fingerprint);
 127         if (fgets(line, sizeof(line), stdin) &&
 128             line[0] != '\0' && line[0] != '\n') {
 129             if (line[0] == 'y' || line[0] == 'Y')
 130                 store_host_key(host, port, keytype, keystr);
 131         } else {
 132             fprintf(stderr, abandoned);
 133             exit(0);
 134         }
 135     }
 136     if (ret == 1) {                    /* key was absent */
 137         fprintf(stderr, absentmsg, fingerprint);
 138         if (fgets(line, sizeof(line), stdin) &&
 139             (line[0] == 'y' || line[0] == 'Y'))
 140             store_host_key(host, port, keytype, keystr);
 141         else {
 142             fprintf(stderr, abandoned);
 143             exit(0);
 144         }
 145     }
 146 }
 147
 148 /* GUI Adaptation - Sept 2000 */
 149 static void send_msg(HWND h, UINT message, WPARAM wParam)
 150 {
 151     while (!PostMessage( h, message, wParam, 0))
 152         SleepEx(1000,TRUE);
 153 }
 154
 155 static void tell_char(FILE *stream, char c)
 156 {
 157     if (!gui_mode)
 158         fputc(c, stream);
 159     else
 160     {
 161         unsigned int msg_id = WM_STD_OUT_CHAR;
 162         if (stream == stderr) msg_id = WM_STD_ERR_CHAR;
 163         send_msg( (HWND)atoi(gui_hwnd), msg_id, (WPARAM)c );
 164     }
 165 }
 166
 167 static void tell_str(FILE *stream, char *str)
 168 {
 169     unsigned int i;
 170
 171     for( i = 0; i < strlen(str); ++i )
 172         tell_char(stream, str[i]);
 173 }
 174
 175 static void tell_user(FILE *stream, char *fmt, ...)
 176 {
 177     char str[0x100]; /* Make the size big enough */
 178     va_list ap;
 179     va_start(ap, fmt);
 180     vsprintf(str, fmt, ap);
 181     va_end(ap);
 182     strcat(str, "\n");
 183     tell_str(stream, str);
 184 }
 185
 186 static void gui_update_stats(char *name, unsigned long size, int percentage, time_t elapsed)
 187 {
 188     unsigned int i;
 189
 190     if (strcmp(name,statname) != 0)
 191     {
 192         for( i = 0; i < strlen(name); ++i )
 193             send_msg( (HWND)atoi(gui_hwnd), WM_STATS_CHAR, (WPARAM)name[i]);
 194         send_msg( (HWND)atoi(gui_hwnd), WM_STATS_CHAR, (WPARAM)'\n' );
 195         strcpy(statname,name);
 196     }
 197     if (statsize != size)
 198     {
 199         send_msg( (HWND)atoi(gui_hwnd), WM_STATS_SIZE, (WPARAM)size );
 200         statsize = size;
 201     }
 202     if (statelapsed != elapsed)
 203     {
 204         send_msg( (HWND)atoi(gui_hwnd), WM_STATS_ELAPSED, (WPARAM)elapsed );
 205         statelapsed = elapsed;
 206     }
 207     if (statperct != percentage)
 208     {
 209         send_msg( (HWND)atoi(gui_hwnd), WM_STATS_PERCENT, (WPARAM)percentage );
 210         statperct = percentage;
 211     }
 212 }
 213
 214 /*
 215  *  Print an error message and perform a fatal exit.
 216  */
 217 void fatalbox(char *fmt, ...)
 218 {
 219     char str[0x100]; /* Make the size big enough */
 220     va_list ap;
 221     va_start(ap, fmt);
 222     strcpy(str, "Fatal:");
 223     vsprintf(str+strlen(str), fmt, ap);
 224     va_end(ap);
 225     strcat(str, "\n");
 226     tell_str(stderr, str);
 227
 228     exit(1);
 229 }
 230 void connection_fatal(char *fmt, ...)
 231 {
 232     char str[0x100]; /* Make the size big enough */
 233     va_list ap;
 234     va_start(ap, fmt);
 235     strcpy(str, "Fatal:");
 236     vsprintf(str+strlen(str), fmt, ap);
 237     va_end(ap);
 238     strcat(str, "\n");
 239     tell_str(stderr, str);
 240
 241     exit(1);
 242 }
 243
 244 /*
 245  * Receive a block of data from the SSH link. Block until all data
 246  * is available.
 247  *
 248  * To do this, we repeatedly call the SSH protocol module, with our
 249  * own trap in from_backend() to catch the data that comes back. We
 250  * do this until we have enough data.
 251  */
 252 static unsigned char *outptr;          /* where to put the data */
 253 static unsigned outlen;                /* how much data required */
 254 static unsigned char *pending = NULL;  /* any spare data */
 255 static unsigned pendlen=0, pendsize=0; /* length and phys. size of buffer */
 256 void from_backend(int is_stderr, char *data, int datalen) {
 257     unsigned char *p = (unsigned char *)data;
 258     unsigned len = (unsigned)datalen;
 259
 260     /*
 261      * stderr data is just spouted to local stderr and otherwise
 262      * ignored.
 263      */
 264     if (is_stderr) {
 265         fwrite(data, 1, len, stderr);
 266         return;
 267     }
 268
 269     inbuf_head = 0;
 270
 271     /*
 272      * If this is before the real session begins, just return.
 273      */
 274     if (!outptr)
 275         return;
 276
 277     if (outlen > 0) {
 278         unsigned used = outlen;
 279         if (used > len) used = len;
 280         memcpy(outptr, p, used);
 281         outptr += used; outlen -= used;
 282         p += used; len -= used;
 283     }
 284
 285     if (len > 0) {
 286         if (pendsize < pendlen + len) {
 287             pendsize = pendlen + len + 4096;
 288             pending = (pending ? realloc(pending, pendsize) :
 289                        malloc(pendsize));
 290             if (!pending)
 291                 fatalbox("Out of memory");
 292         }
 293         memcpy(pending+pendlen, p, len);
 294         pendlen += len;
 295     }
 296 }
 297 static int ssh_scp_recv(unsigned char *buf, int len) {
 298     SOCKET s;
 299
 300     outptr = buf;
 301     outlen = len;
 302
 303     /*
 304      * See if the pending-input block contains some of what we
 305      * need.
 306      */
 307     if (pendlen > 0) {
 308         unsigned pendused = pendlen;
 309         if (pendused > outlen)
 310             pendused = outlen;
 311         memcpy(outptr, pending, pendused);
 312         memmove(pending, pending+pendused, pendlen-pendused);
 313         outptr += pendused;
 314         outlen -= pendused;
 315         pendlen -= pendused;
 316         if (pendlen == 0) {
 317             pendsize = 0;
 318             free(pending);
 319             pending = NULL;
 320         }
 321         if (outlen == 0)
 322             return len;
 323     }
 324
 325     while (outlen > 0) {
 326         fd_set readfds;
 327         s = back->socket();
 328         if (s == INVALID_SOCKET) {
 329             connection_open = FALSE;
 330             return 0;
 331         }
 332         FD_ZERO(&readfds);
 333         FD_SET(s, &readfds);
 334         if (select(1, &readfds, NULL, NULL, NULL) < 0)
 335             return 0;                  /* doom */
 336         back->msg(0, FD_READ);
 337     }
 338
 339     return len;
 340 }
 341
 342 /*
 343  * Loop through the ssh connection and authentication process.
 344  */
 345 static void ssh_scp_init(void) {
 346     SOCKET s;
 347
 348     s = back->socket();
 349     if (s == INVALID_SOCKET)
 350         return;
 351     while (!back->sendok()) {
 352         fd_set readfds;
 353         FD_ZERO(&readfds);
 354         FD_SET(s, &readfds);
 355         if (select(1, &readfds, NULL, NULL, NULL) < 0)
 356             return;                    /* doom */
 357         back->msg(0, FD_READ);
 358     }
 359 }
 360
 361 /*
 362  *  Print an error message and exit after closing the SSH link.
 363  */
 364 static void bump(char *fmt, ...)
 365 {
 366     char str[0x100]; /* Make the size big enough */
 367     va_list ap;
 368     va_start(ap, fmt);
 369     strcpy(str, "Fatal:");
 370     vsprintf(str+strlen(str), fmt, ap);
 371     va_end(ap);
 372     strcat(str, "\n");
 373     tell_str(stderr, str);
 374
 375     if (connection_open) {
 376         char ch;
 377         back->special(TS_EOF);
 378         ssh_scp_recv(&ch, 1);
 379     }
 380     exit(1);
 381 }
 382
 383 static int get_password(const char *prompt, char *str, int maxlen)
 384 {
 385     HANDLE hin, hout;
 386     DWORD savemode, i;
 387
 388     if (password) {
 389         static int tried_once = 0;
 390
 391         if (tried_once) {
 392             return 0;
 393         } else {
 394             strncpy(str, password, maxlen);
 395             str[maxlen-1] = '\0';
 396             tried_once = 1;
 397             return 1;
 398         }
 399     }
 400
 401     /* GUI Adaptation - Sept 2000 */
 402     if (gui_mode) {
 403         if (maxlen>0) str[0] = '\0';
 404     } else {
 405         hin = GetStdHandle(STD_INPUT_HANDLE);
 406         hout = GetStdHandle(STD_OUTPUT_HANDLE);
 407         if (hin == INVALID_HANDLE_VALUE || hout == INVALID_HANDLE_VALUE)
 408             bump("Cannot get standard input/output handles");
 409
 410         GetConsoleMode(hin, &savemode);
 411         SetConsoleMode(hin, (savemode & (~ENABLE_ECHO_INPUT)) |
 412                        ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT);
 413
 414         WriteFile(hout, prompt, strlen(prompt), &i, NULL);
 415         ReadFile(hin, str, maxlen-1, &i, NULL);
 416
 417         SetConsoleMode(hin, savemode);
 418
 419         if ((int)i > maxlen) i = maxlen-1; else i = i - 2;
 420         str[i] = '\0';
 421
 422         WriteFile(hout, "\r\n", 2, &i, NULL);
 423     }
 424
 425     return 1;
 426 }
 427
 428 /*
 429  *  Open an SSH connection to user@host and execute cmd.
 430  */
 431 static void do_cmd(char *host, char *user, char *cmd)
 432 {
 433     char *err, *realhost;
 434
 435     if (host == NULL || host[0] == '\0')
 436         bump("Empty host name");
 437
 438     /* Try to load settings for this host */
 439     do_defaults(host, &cfg);
 440     if (cfg.host[0] == '\0') {
 441         /* No settings for this host; use defaults */
 442         strncpy(cfg.host, host, sizeof(cfg.host)-1);
 443         cfg.host[sizeof(cfg.host)-1] = '\0';
 444         cfg.port = 22;
 445     }
 446
 447     /* Set username */
 448     if (user != NULL && user[0] != '\0') {
 449         strncpy(cfg.username, user, sizeof(cfg.username)-1);
 450         cfg.username[sizeof(cfg.username)-1] = '\0';
 451     } else if (cfg.username[0] == '\0') {
 452         bump("Empty user name");
 453     }
 454
 455     if (cfg.protocol != PROT_SSH)
 456         cfg.port = 22;
 457
 458     if (portnumber)
 459         cfg.port = portnumber;
 460
 461     strncpy(cfg.remote_cmd, cmd, sizeof(cfg.remote_cmd));
 462     cfg.remote_cmd[sizeof(cfg.remote_cmd)-1] = '\0';
 463     cfg.nopty = TRUE;
 464
 465     back = &ssh_backend;
 466
 467     err = back->init(NULL, cfg.host, cfg.port, &realhost);
 468     if (err != NULL)
 469         bump("ssh_init: %s", err);
 470     ssh_scp_init();
 471     if (verbose && realhost != NULL)
 472         tell_user(stderr, "Connected to %s\n", realhost);
 473
 474     connection_open = 1;
 475 }
 476
 477 /*
 478  *  Update statistic information about current file.
 479  */
 480 static void print_stats(char *name, unsigned long size, unsigned long done,
 481                         time_t start, time_t now)
 482 {
 483     float ratebs;
 484     unsigned long eta;
 485     char etastr[10];
 486     int pct;
 487
 488     /* GUI Adaptation - Sept 2000 */
 489     if (gui_mode)
 490         gui_update_stats(name, size, ((done *100) / size), now-start);
 491     else {
 492         if (now > start)
 493             ratebs = (float) done / (now - start);
 494         else
 495             ratebs = (float) done;
 496
 497         if (ratebs < 1.0)
 498             eta = size - done;
 499         else
 500             eta = (unsigned long) ((size - done) / ratebs);
 501         sprintf(etastr, "%02ld:%02ld:%02ld",
 502                 eta / 3600, (eta % 3600) / 60, eta % 60);
 503
 504         pct = (int) (100.0 * (float) done / size);
 505
 506         printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
 507                name, done / 1024, ratebs / 1024.0,
 508                etastr, pct);
 509
 510         if (done == size)
 511             printf("\n");
 512     }
 513 }
 514
 515 /*
 516  *  Find a colon in str and return a pointer to the colon.
 517  *  This is used to separate hostname from filename.
 518  */
 519 static char * colon(char *str)
 520 {
 521     /* We ignore a leading colon, since the hostname cannot be
 522      empty. We also ignore a colon as second character because
 523      of filenames like f:myfile.txt. */
 524     if (str[0] == '\0' ||
 525         str[0] == ':' ||
 526         str[1] == ':')
 527         return (NULL);
 528     while (*str != '\0' &&
 529            *str != ':' &&
 530            *str != '/' &&
 531            *str != '\\')
 532         str++;
 533     if (*str == ':')
 534         return (str);
 535     else
 536         return (NULL);
 537 }
 538
 539 /*
 540  *  Wait for a response from the other side.
 541  *  Return 0 if ok, -1 if error.
 542  */
 543 static int response(void)
 544 {
 545     char ch, resp, rbuf[2048];
 546     int p;
 547
 548     if (ssh_scp_recv(&resp, 1) <= 0)
 549         bump("Lost connection");
 550
 551     p = 0;
 552     switch (resp) {
 553       case 0:           /* ok */
 554         return (0);
 555       default:
 556         rbuf[p++] = resp;
 557         /* fallthrough */
 558       case 1:           /* error */
 559       case 2:           /* fatal error */
 560         do {
 561             if (ssh_scp_recv(&ch, 1) <= 0)
 562                 bump("Protocol error: Lost connection");
 563             rbuf[p++] = ch;
 564         } while (p < sizeof(rbuf) && ch != '\n');
 565         rbuf[p-1] = '\0';
 566         if (resp == 1)
 567             tell_user(stderr, "%s\n", rbuf);
 568         else
 569             bump("%s", rbuf);
 570         errs++;
 571         return (-1);
 572     }
 573 }
 574
 575 /*
 576  *  Send an error message to the other side and to the screen.
 577  *  Increment error counter.
 578  */
 579 static void run_err(const char *fmt, ...)
 580 {
 581     char str[2048];
 582     va_list ap;
 583     va_start(ap, fmt);
 584     errs++;
 585     strcpy(str, "scp: ");
 586     vsprintf(str+strlen(str), fmt, ap);
 587     strcat(str, "\n");
 588     back->send(str, strlen(str));
 589     tell_user(stderr, "%s",str);
 590     va_end(ap);
 591 }
 592
 593 /*
 594  *  Execute the source part of the SCP protocol.
 595  */
 596 static void source(char *src)
 597 {
 598     char buf[2048];
 599     unsigned long size;
 600     char *last;
 601     HANDLE f;
 602     DWORD attr;
 603     unsigned long i;
 604     unsigned long stat_bytes;
 605     time_t stat_starttime, stat_lasttime;
 606
 607     attr = GetFileAttributes(src);
 608     if (attr == (DWORD)-1) {
 609         run_err("%s: No such file or directory", src);
 610         return;
 611     }
 612
 613     if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
 614         if (recursive) {
 615             /*
 616              * Avoid . and .. directories.
 617              */
 618             char *p;
 619             p = strrchr(src, '/');
 620             if (!p)
 621                 p = strrchr(src, '\\');
 622             if (!p)
 623                 p = src;
 624             else
 625                 p++;
 626             if (!strcmp(p, ".") || !strcmp(p, ".."))
 627                 /* skip . and .. */;
 628             else
 629                 rsource(src);
 630         } else {
 631             run_err("%s: not a regular file", src);
 632         }
 633         return;
 634     }
 635
 636     if ((last = strrchr(src, '/')) == NULL)
 637         last = src;
 638     else
 639         last++;
 640     if (strrchr(last, '\\') != NULL)
 641         last = strrchr(last, '\\') + 1;
 642     if (last == src && strchr(src, ':') != NULL)
 643         last = strchr(src, ':') + 1;
 644
 645     f = CreateFile(src, GENERIC_READ, FILE_SHARE_READ, NULL,
 646                    OPEN_EXISTING, 0, 0);
 647     if (f == INVALID_HANDLE_VALUE) {
 648         run_err("%s: Cannot open file", src);
 649         return;
 650     }
 651
 652     if (preserve) {
 653         FILETIME actime, wrtime;
 654         unsigned long mtime, atime;
 655         GetFileTime(f, NULL, &actime, &wrtime);
 656         TIME_WIN_TO_POSIX(actime, atime);
 657         TIME_WIN_TO_POSIX(wrtime, mtime);
 658         sprintf(buf, "T%lu 0 %lu 0\n", mtime, atime);
 659         back->send(buf, strlen(buf));
 660         if (response())
 661             return;
 662     }
 663
 664     size = GetFileSize(f, NULL);
 665     sprintf(buf, "C0644 %lu %s\n", size, last);
 666     if (verbose)
 667         tell_user(stderr, "Sending file modes: %s", buf);
 668     back->send(buf, strlen(buf));
 669     if (response())
 670         return;
 671
 672     if (statistics) {
 673         stat_bytes = 0;
 674         stat_starttime = time(NULL);
 675         stat_lasttime = 0;
 676     }
 677
 678     for (i = 0; i < size; i += 4096) {
 679         char transbuf[4096];
 680         DWORD j, k = 4096;
 681         if (i + k > size) k = size - i;
 682         if (! ReadFile(f, transbuf, k, &j, NULL) || j != k) {
 683             if (statistics) printf("\n");
 684             bump("%s: Read error", src);
 685         }
 686         back->send(transbuf, k);
 687         if (statistics) {
 688             stat_bytes += k;
 689             if (time(NULL) != stat_lasttime ||
 690                 i + k == size) {
 691                 stat_lasttime = time(NULL);
 692                 print_stats(last, size, stat_bytes,
 693                             stat_starttime, stat_lasttime);
 694             }
 695         }
 696     }
 697     CloseHandle(f);
 698
 699     back->send("", 1);
 700     (void) response();
 701 }
 702
 703 /*
 704  *  Recursively send the contents of a directory.
 705  */
 706 static void rsource(char *src)
 707 {
 708     char buf[2048];
 709     char *last;
 710     HANDLE dir;
 711     WIN32_FIND_DATA fdat;
 712     int ok;
 713
 714     if ((last = strrchr(src, '/')) == NULL)
 715         last = src;
 716     else
 717         last++;
 718     if (strrchr(last, '\\') != NULL)
 719         last = strrchr(last, '\\') + 1;
 720     if (last == src && strchr(src, ':') != NULL)
 721         last = strchr(src, ':') + 1;
 722
 723     /* maybe send filetime */
 724
 725     sprintf(buf, "D0755 0 %s\n", last);
 726     if (verbose)
 727         tell_user(stderr, "Entering directory: %s", buf);
 728     back->send(buf, strlen(buf));
 729     if (response())
 730         return;
 731
 732     sprintf(buf, "%s/*", src);
 733     dir = FindFirstFile(buf, &fdat);
 734     ok = (dir != INVALID_HANDLE_VALUE);
 735     while (ok) {
 736         if (strcmp(fdat.cFileName, ".") == 0 ||
 737             strcmp(fdat.cFileName, "..") == 0) {
 738         } else if (strlen(src) + 1 + strlen(fdat.cFileName) >=
 739                    sizeof(buf)) {
 740             run_err("%s/%s: Name too long", src, fdat.cFileName);
 741         } else {
 742             sprintf(buf, "%s/%s", src, fdat.cFileName);
 743             source(buf);
 744         }
 745         ok = FindNextFile(dir, &fdat);
 746     }
 747     FindClose(dir);
 748
 749     sprintf(buf, "E\n");
 750     back->send(buf, strlen(buf));
 751     (void) response();
 752 }
 753
 754 /*
 755  *  Execute the sink part of the SCP protocol.
 756  */
 757 static void sink(char *targ, char *src)
 758 {
 759     char buf[2048];
 760     char namebuf[2048];
 761     char ch;
 762     int targisdir = 0;
 763     int settime;
 764     int exists;
 765     DWORD attr;
 766     HANDLE f;
 767     unsigned long mtime, atime;
 768     unsigned int mode;
 769     unsigned long size, i;
 770     int wrerror = 0;
 771     unsigned long stat_bytes;
 772     time_t stat_starttime, stat_lasttime;
 773     char *stat_name;
 774
 775     attr = GetFileAttributes(targ);
 776     if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_DIRECTORY) != 0)
 777         targisdir = 1;
 778
 779     if (targetshouldbedirectory && !targisdir)
 780         bump("%s: Not a directory", targ);
 781
 782     back->send("", 1);
 783     while (1) {
 784         settime = 0;
 785         gottime:
 786         if (ssh_scp_recv(&ch, 1) <= 0)
 787             return;
 788         if (ch == '\n')
 789             bump("Protocol error: Unexpected newline");
 790         i = 0;
 791         buf[i++] = ch;
 792         do {
 793             if (ssh_scp_recv(&ch, 1) <= 0)
 794                 bump("Lost connection");
 795             buf[i++] = ch;
 796         } while (i < sizeof(buf) && ch != '\n');
 797         buf[i-1] = '\0';
 798         switch (buf[0]) {
 799           case '\01':   /* error */
 800             tell_user(stderr, "%s\n", buf+1);
 801             errs++;
 802             continue;
 803           case '\02':   /* fatal error */
 804             bump("%s", buf+1);
 805           case 'E':
 806             back->send("", 1);
 807             return;
 808           case 'T':
 809             if (sscanf(buf, "T%ld %*d %ld %*d",
 810                        &mtime, &atime) == 2) {
 811                 settime = 1;
 812                 back->send("", 1);
 813                 goto gottime;
 814             }
 815             bump("Protocol error: Illegal time format");
 816           case 'C':
 817           case 'D':
 818             break;
 819           default:
 820             bump("Protocol error: Expected control record");
 821         }
 822
 823         if (sscanf(buf+1, "%u %lu %[^\n]", &mode, &size, namebuf) != 3)
 824             bump("Protocol error: Illegal file descriptor format");
 825         /* Security fix: ensure the file ends up where we asked for it. */
 826         if (src) {
 827             char *p = src + strlen(src);
 828             while (p > src && p[-1] != '/' && p[-1] != '\\')
 829                 p--;
 830             strcpy(namebuf, p);
 831         }
 832         if (targisdir) {
 833             char t[2048];
 834             char *p;
 835             strcpy(t, targ);
 836             if (targ[0] != '\0')
 837                 strcat(t, "/");
 838             p = namebuf + strlen(namebuf);
 839             while (p > namebuf && p[-1] != '/' && p[-1] != '\\')
 840                 p--;
 841             strcat(t, p);
 842             strcpy(namebuf, t);
 843         } else {
 844             strcpy(namebuf, targ);
 845         }
 846         attr = GetFileAttributes(namebuf);
 847         exists = (attr != (DWORD)-1);
 848
 849         if (buf[0] == 'D') {
 850             if (exists && (attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
 851                 run_err("%s: Not a directory", namebuf);
 852                 continue;
 853             }
 854             if (!exists) {
 855                 if (! CreateDirectory(namebuf, NULL)) {
 856                     run_err("%s: Cannot create directory",
 857                             namebuf);
 858                     continue;
 859                 }
 860             }
 861             sink(namebuf, NULL);
 862             /* can we set the timestamp for directories ? */
 863             continue;
 864         }
 865
 866         f = CreateFile(namebuf, GENERIC_WRITE, 0, NULL,
 867                        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 868         if (f == INVALID_HANDLE_VALUE) {
 869             run_err("%s: Cannot create file", namebuf);
 870             continue;
 871         }
 872
 873         back->send("", 1);
 874
 875         if (statistics) {
 876             stat_bytes = 0;
 877             stat_starttime = time(NULL);
 878             stat_lasttime = 0;
 879             if ((stat_name = strrchr(namebuf, '/')) == NULL)
 880                 stat_name = namebuf;
 881             else
 882                 stat_name++;
 883             if (strrchr(stat_name, '\\') != NULL)
 884                 stat_name = strrchr(stat_name, '\\') + 1;
 885         }
 886
 887         for (i = 0; i < size; i += 4096) {
 888             char transbuf[4096];
 889             DWORD j, k = 4096;
 890             if (i + k > size) k = size - i;
 891             if (ssh_scp_recv(transbuf, k) == 0)
 892                 bump("Lost connection");
 893             if (wrerror) continue;
 894             if (! WriteFile(f, transbuf, k, &j, NULL) || j != k) {
 895                 wrerror = 1;
 896                 if (statistics)
 897                     printf("\r%-25.25s | %50s\n",
 898                            stat_name,
 899                            "Write error.. waiting for end of file");
 900                 continue;
 901             }
 902             if (statistics) {
 903                 stat_bytes += k;
 904                 if (time(NULL) > stat_lasttime ||
 905                     i + k == size) {
 906                     stat_lasttime = time(NULL);
 907                     print_stats(stat_name, size, stat_bytes,
 908                                 stat_starttime, stat_lasttime);
 909                 }
 910             }
 911         }
 912         (void) response();
 913
 914         if (settime) {
 915             FILETIME actime, wrtime;
 916             TIME_POSIX_TO_WIN(atime, actime);
 917             TIME_POSIX_TO_WIN(mtime, wrtime);
 918             SetFileTime(f, NULL, &actime, &wrtime);
 919         }
 920
 921         CloseHandle(f);
 922         if (wrerror) {
 923             run_err("%s: Write error", namebuf);
 924             continue;
 925         }
 926         back->send("", 1);
 927     }
 928 }
 929
 930 /*
 931  *  We will copy local files to a remote server.
 932  */
 933 static void toremote(int argc, char *argv[])
 934 {
 935     char *src, *targ, *host, *user;
 936     char *cmd;
 937     int i;
 938
 939     targ = argv[argc-1];
 940
 941     /* Separate host from filename */
 942     host = targ;
 943     targ = colon(targ);
 944     if (targ == NULL)
 945         bump("targ == NULL in toremote()");
 946     *targ++ = '\0';
 947     if (*targ == '\0')
 948         targ = ".";
 949     /* Substitute "." for emtpy target */
 950
 951     /* Separate host and username */
 952     user = host;
 953     host = strrchr(host, '@');
 954     if (host == NULL) {
 955         host = user;
 956         user = NULL;
 957     } else {
 958         *host++ = '\0';
 959         if (*user == '\0')
 960             user = NULL;
 961     }
 962
 963     if (argc == 2) {
 964         /* Find out if the source filespec covers multiple files
 965          if so, we should set the targetshouldbedirectory flag */
 966         HANDLE fh;
 967         WIN32_FIND_DATA fdat;
 968         if (colon(argv[0]) != NULL)
 969             bump("%s: Remote to remote not supported", argv[0]);
 970         fh = FindFirstFile(argv[0], &fdat);
 971         if (fh == INVALID_HANDLE_VALUE)
 972             bump("%s: No such file or directory\n", argv[0]);
 973         if (FindNextFile(fh, &fdat))
 974             targetshouldbedirectory = 1;
 975         FindClose(fh);
 976     }
 977
 978     cmd = smalloc(strlen(targ) + 100);
 979     sprintf(cmd, "scp%s%s%s%s -t %s",
 980             verbose ? " -v" : "",
 981             recursive ? " -r" : "",
 982             preserve ? " -p" : "",
 983             targetshouldbedirectory ? " -d" : "",
 984             targ);
 985     do_cmd(host, user, cmd);
 986     sfree(cmd);
 987
 988     (void) response();
 989
 990     for (i = 0; i < argc - 1; i++) {
 991         HANDLE dir;
 992         WIN32_FIND_DATA fdat;
 993         src = argv[i];
 994         if (colon(src) != NULL) {
 995             tell_user(stderr, "%s: Remote to remote not supported\n", src);
 996             errs++;
 997             continue;
 998         }
 999         dir = FindFirstFile(src, &fdat);
1000         if (dir == INVALID_HANDLE_VALUE) {
1001             run_err("%s: No such file or directory", src);
1002             continue;
1003         }
1004         do {
1005             char *last;
1006             char namebuf[2048];
1007             if (strlen(src) + strlen(fdat.cFileName) >=
1008                 sizeof(namebuf)) {
1009                 tell_user(stderr, "%s: Name too long", src);
1010                 continue;
1011             }
1012             strcpy(namebuf, src);
1013             if ((last = strrchr(namebuf, '/')) == NULL)
1014                 last = namebuf;
1015             else
1016                 last++;
1017             if (strrchr(last, '\\') != NULL)
1018                 last = strrchr(last, '\\') + 1;
1019             if (last == namebuf && strrchr(namebuf, ':') != NULL)
1020                 last = strchr(namebuf, ':') + 1;
1021             strcpy(last, fdat.cFileName);
1022             source(namebuf);
1023         } while (FindNextFile(dir, &fdat));
1024         FindClose(dir);
1025     }
1026 }
1027
1028 /*
1029  *  We will copy files from a remote server to the local machine.
1030  */
1031 static void tolocal(int argc, char *argv[])
1032 {
1033     char *src, *targ, *host, *user;
1034     char *cmd;
1035
1036     if (argc != 2)
1037         bump("More than one remote source not supported");
1038
1039     src = argv[0];
1040     targ = argv[1];
1041
1042     /* Separate host from filename */
1043     host = src;
1044     src = colon(src);
1045     if (src == NULL)
1046         bump("Local to local copy not supported");
1047     *src++ = '\0';
1048     if (*src == '\0')
1049         src = ".";
1050     /* Substitute "." for empty filename */
1051
1052     /* Separate username and hostname */
1053     user = host;
1054     host = strrchr(host, '@');
1055     if (host == NULL) {
1056         host = user;
1057         user = NULL;
1058     } else {
1059         *host++ = '\0';
1060         if (*user == '\0')
1061             user = NULL;
1062     }
1063
1064     cmd = smalloc(strlen(src) + 100);
1065     sprintf(cmd, "scp%s%s%s%s -f %s",
1066             verbose ? " -v" : "",
1067             recursive ? " -r" : "",
1068             preserve ? " -p" : "",
1069             targetshouldbedirectory ? " -d" : "",
1070             src);
1071     do_cmd(host, user, cmd);
1072     sfree(cmd);
1073
1074     sink(targ, src);
1075 }
1076
1077 /*
1078  *  We will issue a list command to get a remote directory.
1079  */
1080 static void get_dir_list(int argc, char *argv[])
1081 {
1082     char *src, *host, *user;
1083     char *cmd, *p, *q;
1084     char c;
1085
1086     src = argv[0];
1087
1088     /* Separate host from filename */
1089     host = src;
1090     src = colon(src);
1091     if (src == NULL)
1092         bump("Local to local copy not supported");
1093     *src++ = '\0';
1094     if (*src == '\0')
1095         src = ".";
1096     /* Substitute "." for empty filename */
1097
1098     /* Separate username and hostname */
1099     user = host;
1100     host = strrchr(host, '@');
1101     if (host == NULL) {
1102         host = user;
1103         user = NULL;
1104     } else {
1105         *host++ = '\0';
1106         if (*user == '\0')
1107             user = NULL;
1108     }
1109
1110     cmd = smalloc(4*strlen(src) + 100);
1111     strcpy(cmd, "ls -la '");
1112     p = cmd + strlen(cmd);
1113     for (q = src; *q; q++) {
1114         if (*q == '\'') {
1115             *p++ = '\''; *p++ = '\\'; *p++ = '\''; *p++ = '\'';
1116         } else {
1117             *p++ = *q;
1118         }
1119     }
1120     *p++ = '\'';
1121     *p = '\0';
1122
1123     do_cmd(host, user, cmd);
1124     sfree(cmd);
1125
1126     while (ssh_scp_recv(&c, 1) > 0)
1127         tell_char(stdout, c);
1128 }
1129
1130 /*
1131  *  Initialize the Win$ock driver.
1132  */
1133 static void init_winsock(void)
1134 {
1135     WORD winsock_ver;
1136     WSADATA wsadata;
1137
1138     winsock_ver = MAKEWORD(1, 1);
1139     if (WSAStartup(winsock_ver, &wsadata))
1140         bump("Unable to initialise WinSock");
1141     if (LOBYTE(wsadata.wVersion) != 1 ||
1142         HIBYTE(wsadata.wVersion) != 1)
1143         bump("WinSock version is incompatible with 1.1");
1144 }
1145
1146 /*
1147  *  Short description of parameters.
1148  */
1149 static void usage(void)
1150 {
1151     printf("PuTTY Secure Copy client\n");
1152     printf("%s\n", ver);
1153     printf("Usage: pscp [options] [user@]host:source target\n");
1154     printf("       pscp [options] source [source...] [user@]host:target\n");
1155     printf("       pscp [options] -ls user@host:filespec\n");
1156     printf("Options:\n");
1157     printf("  -p        preserve file attributes\n");
1158     printf("  -q        quiet, don't show statistics\n");
1159     printf("  -r        copy directories recursively\n");
1160     printf("  -v        show verbose messages\n");
1161     printf("  -P port   connect to specified port\n");
1162     printf("  -pw passw login with specified password\n");
1163     /* GUI Adaptation - Sept 2000 */
1164     printf("  -gui hWnd GUI mode with the windows handle for receiving messages\n");
1165     exit(1);
1166 }
1167
1168 /*
1169  *  Main program (no, really?)
1170  */
1171 int main(int argc, char *argv[])
1172 {
1173     int i;
1174     int list = 0;
1175
1176     default_protocol = PROT_TELNET;
1177
1178     flags = FLAG_STDERR;
1179     ssh_get_password = &get_password;
1180     init_winsock();
1181
1182     for (i = 1; i < argc; i++) {
1183         if (argv[i][0] != '-')
1184             break;
1185         if (strcmp(argv[i], "-v") == 0)
1186             verbose = 1, flags |= FLAG_VERBOSE;
1187         else if (strcmp(argv[i], "-r") == 0)
1188             recursive = 1;
1189         else if (strcmp(argv[i], "-p") == 0)
1190             preserve = 1;
1191         else if (strcmp(argv[i], "-q") == 0)
1192             statistics = 0;
1193         else if (strcmp(argv[i], "-h") == 0 ||
1194                  strcmp(argv[i], "-?") == 0)
1195             usage();
1196         else if (strcmp(argv[i], "-P") == 0 && i+1 < argc)
1197             portnumber = atoi(argv[++i]);
1198         else if (strcmp(argv[i], "-pw") == 0 && i+1 < argc)
1199             password = argv[++i];
1200         else if (strcmp(argv[i], "-gui") == 0 && i+1 < argc) {
1201             gui_hwnd = argv[++i];
1202             gui_mode = 1;
1203         } else if (strcmp(argv[i], "-ls") == 0)
1204                 list = 1;
1205         else if (strcmp(argv[i], "--") == 0)
1206         { i++; break; }
1207         else
1208             usage();
1209     }
1210     argc -= i;
1211     argv += i;
1212
1213     if (list) {
1214         if (argc != 1)
1215             usage();
1216         get_dir_list(argc, argv);
1217
1218     } else {
1219
1220         if (argc < 2)
1221             usage();
1222         if (argc > 2)
1223             targetshouldbedirectory = 1;
1224
1225         if (colon(argv[argc-1]) != NULL)
1226             toremote(argc, argv);
1227         else
1228             tolocal(argc, argv);
1229     }
1230
1231     if (connection_open) {
1232         char ch;
1233         back->special(TS_EOF);
1234         ssh_scp_recv(&ch, 1);
1235     }
1236     WSACleanup();
1237     random_save_seed();
1238
1239     /* GUI Adaptation - August 2000 */
1240     if (gui_mode) {
1241         unsigned int msg_id = WM_RET_ERR_CNT;
1242         if (list) msg_id = WM_LS_RET_ERR_CNT;
1243         while (!PostMessage( (HWND)atoi(gui_hwnd), msg_id, (WPARAM)errs, 0/*lParam*/ ) )
1244             SleepEx(1000,TRUE);
1245     }
1246     return (errs == 0 ? 0 : 1);
1247 }
1248
1249 /* end */