projects / u / mdw / putty / blob
? search:


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