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, const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const char *name)
 439 {
 440     return CreateDirectory(name, NULL) != 0;
 441 }
 442
 443 char *dir_file_cat(const char *dir, const 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         next = now;
 499     } else if (run_timers(now, &next)) {
 500         then = now;
 501         now = GETTICKCOUNT();
 502         if (now - then > next - then)
 503             ticks = 0;
 504         else
 505             ticks = next - now;
 506     } else {
 507         ticks = INFINITE;
 508         /* no need to initialise next here because we can never get
 509          * WAIT_TIMEOUT */
 510     }
 511
 512     handles = handle_get_events(&nhandles);
 513     handles = sresize(handles, nhandles+2, HANDLE);
 514     nallhandles = nhandles;
 515
 516     if (netevent != INVALID_HANDLE_VALUE)
 517         handles[netindex = nallhandles++] = netevent;
 518     else
 519         netindex = -1;
 520     if (other_event != INVALID_HANDLE_VALUE)
 521         handles[otherindex = nallhandles++] = other_event;
 522     else
 523         otherindex = -1;
 524
 525     n = WaitForMultipleObjects(nallhandles, handles, FALSE, ticks);
 526
 527     if ((unsigned)(n - WAIT_OBJECT_0) < (unsigned)nhandles) {
 528         handle_got_event(handles[n - WAIT_OBJECT_0]);
 529     } else if (netindex >= 0 && n == WAIT_OBJECT_0 + netindex) {
 530         WSANETWORKEVENTS things;
 531         SOCKET socket;
 532         extern SOCKET first_socket(int *), next_socket(int *);
 533         extern int select_result(WPARAM, LPARAM);
 534         int i, socketstate;
 535
 536         /*
 537          * We must not call select_result() for any socket
 538          * until we have finished enumerating within the
 539          * tree. This is because select_result() may close
 540          * the socket and modify the tree.
 541          */
 542         /* Count the active sockets. */
 543         i = 0;
 544         for (socket = first_socket(&socketstate);
 545              socket != INVALID_SOCKET;
 546              socket = next_socket(&socketstate)) i++;
 547
 548         /* Expand the buffer if necessary. */
 549         sklist = snewn(i, SOCKET);
 550
 551         /* Retrieve the sockets into sklist. */
 552         skcount = 0;
 553         for (socket = first_socket(&socketstate);
 554              socket != INVALID_SOCKET;
 555              socket = next_socket(&socketstate)) {
 556             sklist[skcount++] = socket;
 557         }
 558
 559         /* Now we're done enumerating; go through the list. */
 560         for (i = 0; i < skcount; i++) {
 561             WPARAM wp;
 562             socket = sklist[i];
 563             wp = (WPARAM) socket;
 564             if (!p_WSAEnumNetworkEvents(socket, NULL, &things)) {
 565                 static const struct { int bit, mask; } eventtypes[] = {
 566                     {FD_CONNECT_BIT, FD_CONNECT},
 567                     {FD_READ_BIT, FD_READ},
 568                     {FD_CLOSE_BIT, FD_CLOSE},
 569                     {FD_OOB_BIT, FD_OOB},
 570                     {FD_WRITE_BIT, FD_WRITE},
 571                     {FD_ACCEPT_BIT, FD_ACCEPT},
 572                 };
 573                 int e;
 574
 575                 noise_ultralight(socket);
 576                 noise_ultralight(things.lNetworkEvents);
 577
 578                 for (e = 0; e < lenof(eventtypes); e++)
 579                     if (things.lNetworkEvents & eventtypes[e].mask) {
 580                         LPARAM lp;
 581                         int err = things.iErrorCode[eventtypes[e].bit];
 582                         lp = WSAMAKESELECTREPLY(eventtypes[e].mask, err);
 583                         select_result(wp, lp);
 584                     }
 585             }
 586         }
 587
 588         sfree(sklist);
 589     }
 590
 591     sfree(handles);
 592
 593     run_toplevel_callbacks();
 594
 595     if (n == WAIT_TIMEOUT) {
 596         now = next;
 597     } else {
 598         now = GETTICKCOUNT();
 599     }
 600
 601     if (otherindex >= 0 && n == WAIT_OBJECT_0 + otherindex)
 602         return 1;
 603
 604     return 0;
 605 }
 606
 607 /*
 608  * Wait for some network data and process it.
 609  *
 610  * We have two variants of this function. One uses select() so that
 611  * it's compatible with WinSock 1. The other uses WSAEventSelect
 612  * and MsgWaitForMultipleObjects, so that we can consistently use
 613  * WSAEventSelect throughout; this enables us to also implement
 614  * ssh_sftp_get_cmdline() using a parallel mechanism.
 615  */
 616 int ssh_sftp_loop_iteration(void)
 617 {
 618     if (p_WSAEventSelect == NULL) {
 619         fd_set readfds;
 620         int ret;
 621         unsigned long now = GETTICKCOUNT(), then;
 622
 623         if (sftp_ssh_socket == INVALID_SOCKET)
 624             return -1;                 /* doom */
 625
 626         if (socket_writable(sftp_ssh_socket))
 627             select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_WRITE);
 628
 629         do {
 630             unsigned long next;
 631             long ticks;
 632             struct timeval tv, *ptv;
 633
 634             if (run_timers(now, &next)) {
 635                 then = now;
 636                 now = GETTICKCOUNT();
 637                 if (now - then > next - then)
 638                     ticks = 0;
 639                 else
 640                     ticks = next - now;
 641                 tv.tv_sec = ticks / 1000;
 642                 tv.tv_usec = ticks % 1000 * 1000;
 643                 ptv = &tv;
 644             } else {
 645                 ptv = NULL;
 646             }
 647
 648             FD_ZERO(&readfds);
 649             FD_SET(sftp_ssh_socket, &readfds);
 650             ret = p_select(1, &readfds, NULL, NULL, ptv);
 651
 652             if (ret < 0)
 653                 return -1;                     /* doom */
 654             else if (ret == 0)
 655                 now = next;
 656             else
 657                 now = GETTICKCOUNT();
 658
 659         } while (ret == 0);
 660
 661         select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_READ);
 662
 663         return 0;
 664     } else {
 665         return do_eventsel_loop(INVALID_HANDLE_VALUE);
 666     }
 667 }
 668
 669 /*
 670  * Read a command line from standard input.
 671  *
 672  * In the presence of WinSock 2, we can use WSAEventSelect to
 673  * mediate between the socket and stdin, meaning we can send
 674  * keepalives and respond to server events even while waiting at
 675  * the PSFTP command prompt. Without WS2, we fall back to a simple
 676  * fgets.
 677  */
 678 struct command_read_ctx {
 679     HANDLE event;
 680     char *line;
 681 };
 682
 683 static DWORD WINAPI command_read_thread(void *param)
 684 {
 685     struct command_read_ctx *ctx = (struct command_read_ctx *) param;
 686
 687     ctx->line = fgetline(stdin);
 688
 689     SetEvent(ctx->event);
 690
 691     return 0;
 692 }
 693
 694 char *ssh_sftp_get_cmdline(const char *prompt, int no_fds_ok)
 695 {
 696     int ret;
 697     struct command_read_ctx actx, *ctx = &actx;
 698     DWORD threadid;
 699     HANDLE hThread;
 700
 701     fputs(prompt, stdout);
 702     fflush(stdout);
 703
 704     if ((sftp_ssh_socket == INVALID_SOCKET && no_fds_ok) ||
 705         p_WSAEventSelect == NULL) {
 706         return fgetline(stdin);        /* very simple */
 707     }
 708
 709     /*
 710      * Create a second thread to read from stdin. Process network
 711      * and timing events until it terminates.
 712      */
 713     ctx->event = CreateEvent(NULL, FALSE, FALSE, NULL);
 714     ctx->line = NULL;
 715
 716     hThread = CreateThread(NULL, 0, command_read_thread, ctx, 0, &threadid);
 717     if (!hThread) {
 718         CloseHandle(ctx->event);
 719         fprintf(stderr, "Unable to create command input thread\n");
 720         cleanup_exit(1);
 721     }
 722
 723     do {
 724         ret = do_eventsel_loop(ctx->event);
 725
 726         /* Error return can only occur if netevent==NULL, and it ain't. */
 727         assert(ret >= 0);
 728     } while (ret == 0);
 729
 730     CloseHandle(hThread);
 731     CloseHandle(ctx->event);
 732
 733     return ctx->line;
 734 }
 735
 736 /* ----------------------------------------------------------------------
 737  * Main program. Parse arguments etc.
 738  */
 739 int main(int argc, char *argv[])
 740 {
 741     int ret;
 742
 743     ret = psftp_main(argc, argv);
 744
 745     return ret;
 746 }