windows/winsftp.c

   1 /*
   2  * winsftp.c: the Windows-specific parts of PSFTP and PSCP.
   3  */
   4
   5 #include <assert.h>
   6
   7 #include "putty.h"
   8 #include "psftp.h"
   9 #include "ssh.h"
  10 #include "int64.h"
  11
  12 char *get_ttymode(void *frontend, const char *mode) { return NULL; }
  13
  14 int get_userpass_input(prompts_t *p, unsigned char *in, int inlen)
  15 {
  16     int ret;
  17     ret = cmdline_get_passwd_input(p, in, inlen);
  18     if (ret == -1)
  19         ret = console_get_userpass_input(p, in, inlen);
  20     return ret;
  21 }
  22
  23 void platform_get_x11_auth(struct X11Display *display, Conf *conf)
  24 {
  25     /* Do nothing, therefore no auth. */
  26 }
  27 const int platform_uses_x11_unix_by_default = TRUE;
  28
  29 /* ----------------------------------------------------------------------
  30  * File access abstraction.
  31  */
  32
  33 /*
  34  * Set local current directory. Returns NULL on success, or else an
  35  * error message which must be freed after printing.
  36  */
  37 char *psftp_lcd(char *dir)
  38 {
  39     char *ret = NULL;
  40
  41     if (!SetCurrentDirectory(dir)) {
  42         LPVOID message;
  43         int i;
  44         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  45                       FORMAT_MESSAGE_FROM_SYSTEM |
  46                       FORMAT_MESSAGE_IGNORE_INSERTS,
  47                       NULL, GetLastError(),
  48                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  49                       (LPTSTR)&message, 0, NULL);
  50         i = strcspn((char *)message, "\n");
  51         ret = dupprintf("%.*s", i, (LPCTSTR)message);
  52         LocalFree(message);
  53     }
  54
  55     return ret;
  56 }
  57
  58 /*
  59  * Get local current directory. Returns a string which must be
  60  * freed.
  61  */
  62 char *psftp_getcwd(void)
  63 {
  64     char *ret = snewn(256, char);
  65     int len = GetCurrentDirectory(256, ret);
  66     if (len > 256)
  67         ret = sresize(ret, len, char);
  68     GetCurrentDirectory(len, ret);
  69     return ret;
  70 }
  71
  72 #define TIME_POSIX_TO_WIN(t, ft) do { \
  73     ULARGE_INTEGER uli; \
  74     uli.QuadPart = ((ULONGLONG)(t) + 11644473600ull) * 10000000ull; \
  75     (ft).dwLowDateTime  = uli.LowPart; \
  76     (ft).dwHighDateTime = uli.HighPart; \
  77 } while(0)
  78 #define TIME_WIN_TO_POSIX(ft, t) do { \
  79     ULARGE_INTEGER uli; \
  80     uli.LowPart  = (ft).dwLowDateTime; \
  81     uli.HighPart = (ft).dwHighDateTime; \
  82     uli.QuadPart = uli.QuadPart / 10000000ull - 11644473600ull; \
  83     (t) = (unsigned long) uli.QuadPart; \
  84 } while(0)
  85
  86 struct RFile {
  87     HANDLE h;
  88 };
  89
  90 RFile *open_existing_file(char *name, uint64 *size,
  91                           unsigned long *mtime, unsigned long *atime,
  92                           long *perms)
  93 {
  94     HANDLE h;
  95     RFile *ret;
  96
  97     h = CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL,
  98                    OPEN_EXISTING, 0, 0);
  99     if (h == INVALID_HANDLE_VALUE)
 100         return NULL;
 101
 102     ret = snew(RFile);
 103     ret->h = h;
 104
 105     if (size)
 106         size->lo=GetFileSize(h, &(size->hi));
 107
 108     if (mtime || atime) {
 109         FILETIME actime, wrtime;
 110         GetFileTime(h, NULL, &actime, &wrtime);
 111         if (atime)
 112             TIME_WIN_TO_POSIX(actime, *atime);
 113         if (mtime)
 114             TIME_WIN_TO_POSIX(wrtime, *mtime);
 115     }
 116
 117     if (perms)
 118         *perms = -1;
 119
 120     return ret;
 121 }
 122
 123 int read_from_file(RFile *f, void *buffer, int length)
 124 {
 125     int ret;
 126     DWORD read;
 127     ret = ReadFile(f->h, buffer, length, &read, NULL);
 128     if (!ret)
 129         return -1;                     /* error */
 130     else
 131         return read;
 132 }
 133
 134 void close_rfile(RFile *f)
 135 {
 136     CloseHandle(f->h);
 137     sfree(f);
 138 }
 139
 140 struct WFile {
 141     HANDLE h;
 142 };
 143
 144 WFile *open_new_file(char *name, long perms)
 145 {
 146     HANDLE h;
 147     WFile *ret;
 148
 149     h = CreateFile(name, GENERIC_WRITE, 0, NULL,
 150                    CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 151     if (h == INVALID_HANDLE_VALUE)
 152         return NULL;
 153
 154     ret = snew(WFile);
 155     ret->h = h;
 156
 157     return ret;
 158 }
 159
 160 WFile *open_existing_wfile(char *name, uint64 *size)
 161 {
 162     HANDLE h;
 163     WFile *ret;
 164
 165     h = CreateFile(name, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 166                    OPEN_EXISTING, 0, 0);
 167     if (h == INVALID_HANDLE_VALUE)
 168         return NULL;
 169
 170     ret = snew(WFile);
 171     ret->h = h;
 172
 173     if (size)
 174         size->lo=GetFileSize(h, &(size->hi));
 175
 176     return ret;
 177 }
 178
 179 int write_to_file(WFile *f, void *buffer, int length)
 180 {
 181     int ret;
 182     DWORD written;
 183     ret = WriteFile(f->h, buffer, length, &written, NULL);
 184     if (!ret)
 185         return -1;                     /* error */
 186     else
 187         return written;
 188 }
 189
 190 void set_file_times(WFile *f, unsigned long mtime, unsigned long atime)
 191 {
 192     FILETIME actime, wrtime;
 193     TIME_POSIX_TO_WIN(atime, actime);
 194     TIME_POSIX_TO_WIN(mtime, wrtime);
 195     SetFileTime(f->h, NULL, &actime, &wrtime);
 196 }
 197
 198 void close_wfile(WFile *f)
 199 {
 200     CloseHandle(f->h);
 201     sfree(f);
 202 }
 203
 204 /* Seek offset bytes through file, from whence, where whence is
 205    FROM_START, FROM_CURRENT, or FROM_END */
 206 int seek_file(WFile *f, uint64 offset, int whence)
 207 {
 208     DWORD movemethod;
 209
 210     switch (whence) {
 211     case FROM_START:
 212         movemethod = FILE_BEGIN;
 213         break;
 214     case FROM_CURRENT:
 215         movemethod = FILE_CURRENT;
 216         break;
 217     case FROM_END:
 218         movemethod = FILE_END;
 219         break;
 220     default:
 221         return -1;
 222     }
 223
 224     SetFilePointer(f->h, offset.lo, &(offset.hi), movemethod);
 225
 226     if (GetLastError() != NO_ERROR)
 227         return -1;
 228     else
 229         return 0;
 230 }
 231
 232 uint64 get_file_posn(WFile *f)
 233 {
 234     uint64 ret;
 235
 236     ret.hi = 0L;
 237     ret.lo = SetFilePointer(f->h, 0L, &(ret.hi), FILE_CURRENT);
 238
 239     return ret;
 240 }
 241
 242 int file_type(char *name)
 243 {
 244     DWORD attr;
 245     attr = GetFileAttributes(name);
 246     /* We know of no `weird' files under Windows. */
 247     if (attr == (DWORD)-1)
 248         return FILE_TYPE_NONEXISTENT;
 249     else if (attr & FILE_ATTRIBUTE_DIRECTORY)
 250         return FILE_TYPE_DIRECTORY;
 251     else
 252         return FILE_TYPE_FILE;
 253 }
 254
 255 struct DirHandle {
 256     HANDLE h;
 257     char *name;
 258 };
 259
 260 DirHandle *open_directory(char *name)
 261 {
 262     HANDLE h;
 263     WIN32_FIND_DATA fdat;
 264     char *findfile;
 265     DirHandle *ret;
 266
 267     /* Enumerate files in dir `foo'. */
 268     findfile = dupcat(name, "/*", NULL);
 269     h = FindFirstFile(findfile, &fdat);
 270     if (h == INVALID_HANDLE_VALUE)
 271         return NULL;
 272     sfree(findfile);
 273
 274     ret = snew(DirHandle);
 275     ret->h = h;
 276     ret->name = dupstr(fdat.cFileName);
 277     return ret;
 278 }
 279
 280 char *read_filename(DirHandle *dir)
 281 {
 282     do {
 283
 284         if (!dir->name) {
 285             WIN32_FIND_DATA fdat;
 286             int ok = FindNextFile(dir->h, &fdat);
 287             if (!ok)
 288                 return NULL;
 289             else
 290                 dir->name = dupstr(fdat.cFileName);
 291         }
 292
 293         assert(dir->name);
 294         if (dir->name[0] == '.' &&
 295             (dir->name[1] == '\0' ||
 296              (dir->name[1] == '.' && dir->name[2] == '\0'))) {
 297             sfree(dir->name);
 298             dir->name = NULL;
 299         }
 300
 301     } while (!dir->name);
 302
 303     if (dir->name) {
 304         char *ret = dir->name;
 305         dir->name = NULL;
 306         return ret;
 307     } else
 308         return NULL;
 309 }
 310
 311 void close_directory(DirHandle *dir)
 312 {
 313     FindClose(dir->h);
 314     if (dir->name)
 315         sfree(dir->name);
 316     sfree(dir);
 317 }
 318
 319 int test_wildcard(char *name, int cmdline)
 320 {
 321     HANDLE fh;
 322     WIN32_FIND_DATA fdat;
 323
 324     /* First see if the exact name exists. */
 325     if (GetFileAttributes(name) != (DWORD)-1)
 326         return WCTYPE_FILENAME;
 327
 328     /* Otherwise see if a wildcard match finds anything. */
 329     fh = FindFirstFile(name, &fdat);
 330     if (fh == INVALID_HANDLE_VALUE)
 331         return WCTYPE_NONEXISTENT;
 332
 333     FindClose(fh);
 334     return WCTYPE_WILDCARD;
 335 }
 336
 337 struct WildcardMatcher {
 338     HANDLE h;
 339     char *name;
 340     char *srcpath;
 341 };
 342
 343 /*
 344  * Return a pointer to the portion of str that comes after the last
 345  * slash (or backslash or colon, if `local' is TRUE).
 346  */
 347 static char *stripslashes(char *str, int local)
 348 {
 349     char *p;
 350
 351     if (local) {
 352         p = strchr(str, ':');
 353         if (p) str = p+1;
 354     }
 355
 356     p = strrchr(str, '/');
 357     if (p) str = p+1;
 358
 359     if (local) {
 360         p = strrchr(str, '\\');
 361         if (p) str = p+1;
 362     }
 363
 364     return str;
 365 }
 366
 367 WildcardMatcher *begin_wildcard_matching(char *name)
 368 {
 369     HANDLE h;
 370     WIN32_FIND_DATA fdat;
 371     WildcardMatcher *ret;
 372     char *last;
 373
 374     h = FindFirstFile(name, &fdat);
 375     if (h == INVALID_HANDLE_VALUE)
 376         return NULL;
 377
 378     ret = snew(WildcardMatcher);
 379     ret->h = h;
 380     ret->srcpath = dupstr(name);
 381     last = stripslashes(ret->srcpath, 1);
 382     *last = '\0';
 383     if (fdat.cFileName[0] == '.' &&
 384         (fdat.cFileName[1] == '\0' ||
 385          (fdat.cFileName[1] == '.' && fdat.cFileName[2] == '\0')))
 386         ret->name = NULL;
 387     else
 388         ret->name = dupcat(ret->srcpath, fdat.cFileName, NULL);
 389
 390     return ret;
 391 }
 392
 393 char *wildcard_get_filename(WildcardMatcher *dir)
 394 {
 395     while (!dir->name) {
 396         WIN32_FIND_DATA fdat;
 397         int ok = FindNextFile(dir->h, &fdat);
 398
 399         if (!ok)
 400             return NULL;
 401
 402         if (fdat.cFileName[0] == '.' &&
 403             (fdat.cFileName[1] == '\0' ||
 404              (fdat.cFileName[1] == '.' && fdat.cFileName[2] == '\0')))
 405             dir->name = NULL;
 406         else
 407             dir->name = dupcat(dir->srcpath, fdat.cFileName, NULL);
 408     }
 409
 410     if (dir->name) {
 411         char *ret = dir->name;
 412         dir->name = NULL;
 413         return ret;
 414     } else
 415         return NULL;
 416 }
 417
 418 void finish_wildcard_matching(WildcardMatcher *dir)
 419 {
 420     FindClose(dir->h);
 421     if (dir->name)
 422         sfree(dir->name);
 423     sfree(dir->srcpath);
 424     sfree(dir);
 425 }
 426
 427 int vet_filename(char *name)
 428 {
 429     if (strchr(name, '/') || strchr(name, '\\') || strchr(name, ':'))
 430         return FALSE;
 431
 432     if (!name[strspn(name, ".")])      /* entirely composed of dots */
 433         return FALSE;
 434
 435     return TRUE;
 436 }
 437
 438 int create_directory(char *name)
 439 {
 440     return CreateDirectory(name, NULL) != 0;
 441 }
 442
 443 char *dir_file_cat(char *dir, char *file)
 444 {
 445     return dupcat(dir, "\\", file, NULL);
 446 }
 447
 448 /* ----------------------------------------------------------------------
 449  * Platform-specific network handling.
 450  */
 451
 452 /*
 453  * Be told what socket we're supposed to be using.
 454  */
 455 static SOCKET sftp_ssh_socket = INVALID_SOCKET;
 456 static HANDLE netevent = INVALID_HANDLE_VALUE;
 457 char *do_select(SOCKET skt, int startup)
 458 {
 459     int events;
 460     if (startup)
 461         sftp_ssh_socket = skt;
 462     else
 463         sftp_ssh_socket = INVALID_SOCKET;
 464
 465     if (p_WSAEventSelect) {
 466         if (startup) {
 467             events = (FD_CONNECT | FD_READ | FD_WRITE |
 468                       FD_OOB | FD_CLOSE | FD_ACCEPT);
 469             netevent = CreateEvent(NULL, FALSE, FALSE, NULL);
 470         } else {
 471             events = 0;
 472         }
 473         if (p_WSAEventSelect(skt, netevent, events) == SOCKET_ERROR) {
 474             switch (p_WSAGetLastError()) {
 475               case WSAENETDOWN:
 476                 return "Network is down";
 477               default:
 478                 return "WSAEventSelect(): unknown error";
 479             }
 480         }
 481     }
 482     return NULL;
 483 }
 484 extern int select_result(WPARAM, LPARAM);
 485
 486 int do_eventsel_loop(HANDLE other_event)
 487 {
 488     int n, nhandles, nallhandles, netindex, otherindex;
 489     unsigned long next, then;
 490     long ticks;
 491     HANDLE *handles;
 492     SOCKET *sklist;
 493     int skcount;
 494     unsigned long now = GETTICKCOUNT();
 495
 496     if (toplevel_callback_pending()) {
 497         ticks = 0;
 498     } else if (run_timers(now, &next)) {
 499         then = now;
 500         now = GETTICKCOUNT();
 501         if (now - then > next - then)
 502             ticks = 0;
 503         else
 504             ticks = next - now;
 505     } else {
 506         ticks = INFINITE;
 507     }
 508
 509     handles = handle_get_events(&nhandles);
 510     handles = sresize(handles, nhandles+2, HANDLE);
 511     nallhandles = nhandles;
 512
 513     if (netevent != INVALID_HANDLE_VALUE)
 514         handles[netindex = nallhandles++] = netevent;
 515     else
 516         netindex = -1;
 517     if (other_event != INVALID_HANDLE_VALUE)
 518         handles[otherindex = nallhandles++] = other_event;
 519     else
 520         otherindex = -1;
 521
 522     n = WaitForMultipleObjects(nallhandles, handles, FALSE, ticks);
 523
 524     if ((unsigned)(n - WAIT_OBJECT_0) < (unsigned)nhandles) {
 525         handle_got_event(handles[n - WAIT_OBJECT_0]);
 526     } else if (netindex >= 0 && n == WAIT_OBJECT_0 + netindex) {
 527         WSANETWORKEVENTS things;
 528         SOCKET socket;
 529         extern SOCKET first_socket(int *), next_socket(int *);
 530         extern int select_result(WPARAM, LPARAM);
 531         int i, socketstate;
 532
 533         /*
 534          * We must not call select_result() for any socket
 535          * until we have finished enumerating within the
 536          * tree. This is because select_result() may close
 537          * the socket and modify the tree.
 538          */
 539         /* Count the active sockets. */
 540         i = 0;
 541         for (socket = first_socket(&socketstate);
 542              socket != INVALID_SOCKET;
 543              socket = next_socket(&socketstate)) i++;
 544
 545         /* Expand the buffer if necessary. */
 546         sklist = snewn(i, SOCKET);
 547
 548         /* Retrieve the sockets into sklist. */
 549         skcount = 0;
 550         for (socket = first_socket(&socketstate);
 551              socket != INVALID_SOCKET;
 552              socket = next_socket(&socketstate)) {
 553             sklist[skcount++] = socket;
 554         }
 555
 556         /* Now we're done enumerating; go through the list. */
 557         for (i = 0; i < skcount; i++) {
 558             WPARAM wp;
 559             socket = sklist[i];
 560             wp = (WPARAM) socket;
 561             if (!p_WSAEnumNetworkEvents(socket, NULL, &things)) {
 562                 static const struct { int bit, mask; } eventtypes[] = {
 563                     {FD_CONNECT_BIT, FD_CONNECT},
 564                     {FD_READ_BIT, FD_READ},
 565                     {FD_CLOSE_BIT, FD_CLOSE},
 566                     {FD_OOB_BIT, FD_OOB},
 567                     {FD_WRITE_BIT, FD_WRITE},
 568                     {FD_ACCEPT_BIT, FD_ACCEPT},
 569                 };
 570                 int e;
 571
 572                 noise_ultralight(socket);
 573                 noise_ultralight(things.lNetworkEvents);
 574
 575                 for (e = 0; e < lenof(eventtypes); e++)
 576                     if (things.lNetworkEvents & eventtypes[e].mask) {
 577                         LPARAM lp;
 578                         int err = things.iErrorCode[eventtypes[e].bit];
 579                         lp = WSAMAKESELECTREPLY(eventtypes[e].mask, err);
 580                         select_result(wp, lp);
 581                     }
 582             }
 583         }
 584
 585         sfree(sklist);
 586     }
 587
 588     sfree(handles);
 589
 590     run_toplevel_callbacks();
 591
 592     if (n == WAIT_TIMEOUT) {
 593         now = next;
 594     } else {
 595         now = GETTICKCOUNT();
 596     }
 597
 598     if (otherindex >= 0 && n == WAIT_OBJECT_0 + otherindex)
 599         return 1;
 600
 601     return 0;
 602 }
 603
 604 /*
 605  * Wait for some network data and process it.
 606  *
 607  * We have two variants of this function. One uses select() so that
 608  * it's compatible with WinSock 1. The other uses WSAEventSelect
 609  * and MsgWaitForMultipleObjects, so that we can consistently use
 610  * WSAEventSelect throughout; this enables us to also implement
 611  * ssh_sftp_get_cmdline() using a parallel mechanism.
 612  */
 613 int ssh_sftp_loop_iteration(void)
 614 {
 615     if (p_WSAEventSelect == NULL) {
 616         fd_set readfds;
 617         int ret;
 618         unsigned long now = GETTICKCOUNT(), then;
 619
 620         if (sftp_ssh_socket == INVALID_SOCKET)
 621             return -1;                 /* doom */
 622
 623         if (socket_writable(sftp_ssh_socket))
 624             select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_WRITE);
 625
 626         do {
 627             unsigned long next;
 628             long ticks;
 629             struct timeval tv, *ptv;
 630
 631             if (run_timers(now, &next)) {
 632                 then = now;
 633                 now = GETTICKCOUNT();
 634                 if (now - then > next - then)
 635                     ticks = 0;
 636                 else
 637                     ticks = next - now;
 638                 tv.tv_sec = ticks / 1000;
 639                 tv.tv_usec = ticks % 1000 * 1000;
 640                 ptv = &tv;
 641             } else {
 642                 ptv = NULL;
 643             }
 644
 645             FD_ZERO(&readfds);
 646             FD_SET(sftp_ssh_socket, &readfds);
 647             ret = p_select(1, &readfds, NULL, NULL, ptv);
 648
 649             if (ret < 0)
 650                 return -1;                     /* doom */
 651             else if (ret == 0)
 652                 now = next;
 653             else
 654                 now = GETTICKCOUNT();
 655
 656         } while (ret == 0);
 657
 658         select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_READ);
 659
 660         return 0;
 661     } else {
 662         return do_eventsel_loop(INVALID_HANDLE_VALUE);
 663     }
 664 }
 665
 666 /*
 667  * Read a command line from standard input.
 668  *
 669  * In the presence of WinSock 2, we can use WSAEventSelect to
 670  * mediate between the socket and stdin, meaning we can send
 671  * keepalives and respond to server events even while waiting at
 672  * the PSFTP command prompt. Without WS2, we fall back to a simple
 673  * fgets.
 674  */
 675 struct command_read_ctx {
 676     HANDLE event;
 677     char *line;
 678 };
 679
 680 static DWORD WINAPI command_read_thread(void *param)
 681 {
 682     struct command_read_ctx *ctx = (struct command_read_ctx *) param;
 683
 684     ctx->line = fgetline(stdin);
 685
 686     SetEvent(ctx->event);
 687
 688     return 0;
 689 }
 690
 691 char *ssh_sftp_get_cmdline(char *prompt, int no_fds_ok)
 692 {
 693     int ret;
 694     struct command_read_ctx actx, *ctx = &actx;
 695     DWORD threadid;
 696
 697     fputs(prompt, stdout);
 698     fflush(stdout);
 699
 700     if ((sftp_ssh_socket == INVALID_SOCKET && no_fds_ok) ||
 701         p_WSAEventSelect == NULL) {
 702         return fgetline(stdin);        /* very simple */
 703     }
 704
 705     /*
 706      * Create a second thread to read from stdin. Process network
 707      * and timing events until it terminates.
 708      */
 709     ctx->event = CreateEvent(NULL, FALSE, FALSE, NULL);
 710     ctx->line = NULL;
 711
 712     if (!CreateThread(NULL, 0, command_read_thread,
 713                       ctx, 0, &threadid)) {
 714         fprintf(stderr, "Unable to create command input thread\n");
 715         cleanup_exit(1);
 716     }
 717
 718     do {
 719         ret = do_eventsel_loop(ctx->event);
 720
 721         /* Error return can only occur if netevent==NULL, and it ain't. */
 722         assert(ret >= 0);
 723     } while (ret == 0);
 724
 725     return ctx->line;
 726 }
 727
 728 /* ----------------------------------------------------------------------
 729  * Main program. Parse arguments etc.
 730  */
 731 int main(int argc, char *argv[])
 732 {
 733     int ret;
 734
 735     ret = psftp_main(argc, argv);
 736
 737     return ret;
 738 }