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