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