?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 0b5f656d0c5c34ddfb204e40e069e78078c58084
[wine/hacks.git] / dlls / wininet / ftp.c
blob27d3b43a1cd6ea2ca27b2b06d0c911bc518cf818
1 /*
2 * WININET - Ftp implementation
3 *
4 * Copyright 1999 Corel Corporation
5 * Copyright 2004 Mike McCormack for CodeWeavers
6 * Copyright 2004 Kevin Koltzau
7 * Copyright 2007 Hans Leidekker
8 *
9 * Ulrich Czekalla
10 * Noureddine Jemmali
11 *
12 * Copyright 2000 Andreas Mohr
13 * Copyright 2002 Jaco Greeff
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 */
29
30 #include "config.h"
31 #include "wine/port.h"
32
33 #include <errno.h>
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <sys/types.h>
39 #ifdef HAVE_SYS_SOCKET_H
40 # include <sys/socket.h>
41 #endif
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45 #include <time.h>
46 #include <assert.h>
47
48 #include "windef.h"
49 #include "winbase.h"
50 #include "wingdi.h"
51 #include "winuser.h"
52 #include "wininet.h"
53 #include "winnls.h"
54 #include "winerror.h"
55 #include "winreg.h"
56 #include "winternl.h"
57 #include "shlwapi.h"
58
59 #include "wine/debug.h"
60 #include "internet.h"
61
62 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
63
64 #define DATA_PACKET_SIZE 0x2000
65 #define szCRLF "\r\n"
66 #define MAX_BACKLOG 5
67
68 /* Testing shows that Windows only accepts dwFlags where the last
69 * 3 (yes 3) bits define FTP_TRANSFER_TYPE_UNKNOWN, FTP_TRANSFER_TYPE_ASCII or FTP_TRANSFER_TYPE_BINARY.
70 */
71 #define FTP_CONDITION_MASK 0x0007
72
73 typedef enum {
74 /* FTP commands with arguments. */
75 FTP_CMD_ACCT,
76 FTP_CMD_CWD,
77 FTP_CMD_DELE,
78 FTP_CMD_MKD,
79 FTP_CMD_PASS,
80 FTP_CMD_PORT,
81 FTP_CMD_RETR,
82 FTP_CMD_RMD,
83 FTP_CMD_RNFR,
84 FTP_CMD_RNTO,
85 FTP_CMD_STOR,
86 FTP_CMD_TYPE,
87 FTP_CMD_USER,
88 FTP_CMD_SIZE,
89
90 /* FTP commands without arguments. */
91 FTP_CMD_ABOR,
92 FTP_CMD_LIST,
93 FTP_CMD_NLST,
94 FTP_CMD_PASV,
95 FTP_CMD_PWD,
96 FTP_CMD_QUIT,
97 } FTP_COMMAND;
98
99 static const CHAR *const szFtpCommands[] = {
100 "ACCT",
101 "CWD",
102 "DELE",
103 "MKD",
104 "PASS",
105 "PORT",
106 "RETR",
107 "RMD",
108 "RNFR",
109 "RNTO",
110 "STOR",
111 "TYPE",
112 "USER",
113 "SIZE",
114 "ABOR",
115 "LIST",
116 "NLST",
117 "PASV",
118 "PWD",
119 "QUIT",
120 };
121
122 static const CHAR szMonths[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
123 static const WCHAR szNoAccount[] = {'n','o','a','c','c','o','u','n','t','\0'};
124
125 static void FTP_CloseFileTransferHandle(LPWININETHANDLEHEADER hdr);
126 static void FTP_CloseSessionHandle(LPWININETHANDLEHEADER hdr);
127 static void FTP_CloseConnection(LPWININETHANDLEHEADER hdr);
128 static void FTP_CloseFindNextHandle(LPWININETHANDLEHEADER hdr);
129 static BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam,
130 INTERNET_STATUS_CALLBACK lpfnStatusCB, LPWININETHANDLEHEADER hdr, DWORD_PTR dwContext);
131 static BOOL FTP_SendStore(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType);
132 static BOOL FTP_GetDataSocket(LPWININETFTPSESSIONW lpwfs, LPINT nDataSocket);
133 static BOOL FTP_SendData(LPWININETFTPSESSIONW lpwfs, INT nDataSocket, HANDLE hFile);
134 static INT FTP_ReceiveResponse(LPWININETFTPSESSIONW lpwfs, DWORD_PTR dwContext);
135 static BOOL FTP_SendRetrieve(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType);
136 static BOOL FTP_RetrieveFileData(LPWININETFTPSESSIONW lpwfs, INT nDataSocket, HANDLE hFile);
137 static BOOL FTP_InitListenSocket(LPWININETFTPSESSIONW lpwfs);
138 static BOOL FTP_ConnectToHost(LPWININETFTPSESSIONW lpwfs);
139 static BOOL FTP_SendPassword(LPWININETFTPSESSIONW lpwfs);
140 static BOOL FTP_SendAccount(LPWININETFTPSESSIONW lpwfs);
141 static BOOL FTP_SendType(LPWININETFTPSESSIONW lpwfs, DWORD dwType);
142 static BOOL FTP_SendPort(LPWININETFTPSESSIONW lpwfs);
143 static BOOL FTP_DoPassive(LPWININETFTPSESSIONW lpwfs);
144 static BOOL FTP_SendPortOrPasv(LPWININETFTPSESSIONW lpwfs);
145 static BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp);
146 static BOOL FTP_ParseNextFile(INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW fileprop);
147 static BOOL FTP_ParseDirectory(LPWININETFTPSESSIONW lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
148 LPFILEPROPERTIESW *lpafp, LPDWORD dwfp);
149 static HINTERNET FTP_ReceiveFileList(LPWININETFTPSESSIONW lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
150 LPWIN32_FIND_DATAW lpFindFileData, DWORD_PTR dwContext);
151 static DWORD FTP_SetResponseError(DWORD dwResponse);
152
153 /***********************************************************************
154 * FtpPutFileA (WININET.@)
155 *
156 * Uploads a file to the FTP server
157 *
158 * RETURNS
159 * TRUE on success
160 * FALSE on failure
161 *
162 */
163 BOOL WINAPI FtpPutFileA(HINTERNET hConnect, LPCSTR lpszLocalFile,
164 LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
165 {
166 LPWSTR lpwzLocalFile;
167 LPWSTR lpwzNewRemoteFile;
168 BOOL ret;
169
170 lpwzLocalFile = lpszLocalFile?WININET_strdup_AtoW(lpszLocalFile):NULL;
171 lpwzNewRemoteFile = lpszNewRemoteFile?WININET_strdup_AtoW(lpszNewRemoteFile):NULL;
172 ret = FtpPutFileW(hConnect, lpwzLocalFile, lpwzNewRemoteFile,
173 dwFlags, dwContext);
174 HeapFree(GetProcessHeap(), 0, lpwzLocalFile);
175 HeapFree(GetProcessHeap(), 0, lpwzNewRemoteFile);
176 return ret;
177 }
178
179 static void AsyncFtpPutFileProc(WORKREQUEST *workRequest)
180 {
181 struct WORKREQ_FTPPUTFILEW const *req = &workRequest->u.FtpPutFileW;
182 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
183
184 TRACE("%p\n", lpwfs);
185
186 FTP_FtpPutFileW(lpwfs, req->lpszLocalFile,
187 req->lpszNewRemoteFile, req->dwFlags, req->dwContext);
188
189 HeapFree(GetProcessHeap(), 0, req->lpszLocalFile);
190 HeapFree(GetProcessHeap(), 0, req->lpszNewRemoteFile);
191 }
192
193 /***********************************************************************
194 * FtpPutFileW (WININET.@)
195 *
196 * Uploads a file to the FTP server
197 *
198 * RETURNS
199 * TRUE on success
200 * FALSE on failure
201 *
202 */
203 BOOL WINAPI FtpPutFileW(HINTERNET hConnect, LPCWSTR lpszLocalFile,
204 LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
205 {
206 LPWININETFTPSESSIONW lpwfs;
207 LPWININETAPPINFOW hIC = NULL;
208 BOOL r = FALSE;
209
210 if (!lpszLocalFile || !lpszNewRemoteFile)
211 {
212 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
213 return FALSE;
214 }
215
216 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hConnect );
217 if (!lpwfs)
218 {
219 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
220 return FALSE;
221 }
222
223 if (WH_HFTPSESSION != lpwfs->hdr.htype)
224 {
225 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
226 goto lend;
227 }
228
229 if (lpwfs->download_in_progress != NULL)
230 {
231 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
232 goto lend;
233 }
234
235 if ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
236 {
237 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
238 goto lend;
239 }
240
241 hIC = lpwfs->lpAppInfo;
242 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
243 {
244 WORKREQUEST workRequest;
245 struct WORKREQ_FTPPUTFILEW *req = &workRequest.u.FtpPutFileW;
246
247 workRequest.asyncproc = AsyncFtpPutFileProc;
248 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
249 req->lpszLocalFile = WININET_strdupW(lpszLocalFile);
250 req->lpszNewRemoteFile = WININET_strdupW(lpszNewRemoteFile);
251 req->dwFlags = dwFlags;
252 req->dwContext = dwContext;
253
254 r = INTERNET_AsyncCall(&workRequest);
255 }
256 else
257 {
258 r = FTP_FtpPutFileW(lpwfs, lpszLocalFile,
259 lpszNewRemoteFile, dwFlags, dwContext);
260 }
261
262 lend:
263 WININET_Release( &lpwfs->hdr );
264
265 return r;
266 }
267
268 /***********************************************************************
269 * FTP_FtpPutFileW (Internal)
270 *
271 * Uploads a file to the FTP server
272 *
273 * RETURNS
274 * TRUE on success
275 * FALSE on failure
276 *
277 */
278 BOOL WINAPI FTP_FtpPutFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszLocalFile,
279 LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
280 {
281 HANDLE hFile;
282 BOOL bSuccess = FALSE;
283 LPWININETAPPINFOW hIC = NULL;
284 INT nResCode;
285
286 TRACE(" lpszLocalFile(%s) lpszNewRemoteFile(%s)\n", debugstr_w(lpszLocalFile), debugstr_w(lpszNewRemoteFile));
287
288 /* Clear any error information */
289 INTERNET_SetLastError(0);
290
291 /* Open file to be uploaded */
292 if (INVALID_HANDLE_VALUE ==
293 (hFile = CreateFileW(lpszLocalFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0)))
294 /* Let CreateFile set the appropriate error */
295 return FALSE;
296
297 hIC = lpwfs->lpAppInfo;
298
299 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
300
301 if (FTP_SendStore(lpwfs, lpszNewRemoteFile, dwFlags))
302 {
303 INT nDataSocket;
304
305 /* Get data socket to server */
306 if (FTP_GetDataSocket(lpwfs, &nDataSocket))
307 {
308 FTP_SendData(lpwfs, nDataSocket, hFile);
309 closesocket(nDataSocket);
310 nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
311 if (nResCode)
312 {
313 if (nResCode == 226)
314 bSuccess = TRUE;
315 else
316 FTP_SetResponseError(nResCode);
317 }
318 }
319 }
320
321 if (lpwfs->lstnSocket != -1)
322 closesocket(lpwfs->lstnSocket);
323
324 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
325 {
326 INTERNET_ASYNC_RESULT iar;
327
328 iar.dwResult = (DWORD)bSuccess;
329 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
330 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
331 &iar, sizeof(INTERNET_ASYNC_RESULT));
332 }
333
334 CloseHandle(hFile);
335
336 return bSuccess;
337 }
338
339
340 /***********************************************************************
341 * FtpSetCurrentDirectoryA (WININET.@)
342 *
343 * Change the working directory on the FTP server
344 *
345 * RETURNS
346 * TRUE on success
347 * FALSE on failure
348 *
349 */
350 BOOL WINAPI FtpSetCurrentDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
351 {
352 LPWSTR lpwzDirectory;
353 BOOL ret;
354
355 lpwzDirectory = lpszDirectory?WININET_strdup_AtoW(lpszDirectory):NULL;
356 ret = FtpSetCurrentDirectoryW(hConnect, lpwzDirectory);
357 HeapFree(GetProcessHeap(), 0, lpwzDirectory);
358 return ret;
359 }
360
361
362 static void AsyncFtpSetCurrentDirectoryProc(WORKREQUEST *workRequest)
363 {
364 struct WORKREQ_FTPSETCURRENTDIRECTORYW const *req = &workRequest->u.FtpSetCurrentDirectoryW;
365 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
366
367 TRACE("%p\n", lpwfs);
368
369 FTP_FtpSetCurrentDirectoryW(lpwfs, req->lpszDirectory);
370 HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
371 }
372
373 /***********************************************************************
374 * FtpSetCurrentDirectoryW (WININET.@)
375 *
376 * Change the working directory on the FTP server
377 *
378 * RETURNS
379 * TRUE on success
380 * FALSE on failure
381 *
382 */
383 BOOL WINAPI FtpSetCurrentDirectoryW(HINTERNET hConnect, LPCWSTR lpszDirectory)
384 {
385 LPWININETFTPSESSIONW lpwfs = NULL;
386 LPWININETAPPINFOW hIC = NULL;
387 BOOL r = FALSE;
388
389 if (!lpszDirectory)
390 {
391 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
392 goto lend;
393 }
394
395 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hConnect );
396 if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
397 {
398 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
399 goto lend;
400 }
401
402 if (lpwfs->download_in_progress != NULL)
403 {
404 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
405 goto lend;
406 }
407
408 TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
409
410 hIC = lpwfs->lpAppInfo;
411 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
412 {
413 WORKREQUEST workRequest;
414 struct WORKREQ_FTPSETCURRENTDIRECTORYW *req;
415
416 workRequest.asyncproc = AsyncFtpSetCurrentDirectoryProc;
417 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
418 req = &workRequest.u.FtpSetCurrentDirectoryW;
419 req->lpszDirectory = WININET_strdupW(lpszDirectory);
420
421 r = INTERNET_AsyncCall(&workRequest);
422 }
423 else
424 {
425 r = FTP_FtpSetCurrentDirectoryW(lpwfs, lpszDirectory);
426 }
427
428 lend:
429 if( lpwfs )
430 WININET_Release( &lpwfs->hdr );
431
432 return r;
433 }
434
435
436 /***********************************************************************
437 * FTP_FtpSetCurrentDirectoryW (Internal)
438 *
439 * Change the working directory on the FTP server
440 *
441 * RETURNS
442 * TRUE on success
443 * FALSE on failure
444 *
445 */
446 BOOL WINAPI FTP_FtpSetCurrentDirectoryW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszDirectory)
447 {
448 INT nResCode;
449 LPWININETAPPINFOW hIC = NULL;
450 DWORD bSuccess = FALSE;
451
452 TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
453
454 /* Clear any error information */
455 INTERNET_SetLastError(0);
456
457 hIC = lpwfs->lpAppInfo;
458 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_CWD, lpszDirectory,
459 lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
460 goto lend;
461
462 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
463
464 if (nResCode)
465 {
466 if (nResCode == 250)
467 bSuccess = TRUE;
468 else
469 FTP_SetResponseError(nResCode);
470 }
471
472 lend:
473 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
474 {
475 INTERNET_ASYNC_RESULT iar;
476
477 iar.dwResult = (DWORD)bSuccess;
478 iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
479 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
480 &iar, sizeof(INTERNET_ASYNC_RESULT));
481 }
482 return bSuccess;
483 }
484
485
486 /***********************************************************************
487 * FtpCreateDirectoryA (WININET.@)
488 *
489 * Create new directory on the FTP server
490 *
491 * RETURNS
492 * TRUE on success
493 * FALSE on failure
494 *
495 */
496 BOOL WINAPI FtpCreateDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
497 {
498 LPWSTR lpwzDirectory;
499 BOOL ret;
500
501 lpwzDirectory = lpszDirectory?WININET_strdup_AtoW(lpszDirectory):NULL;
502 ret = FtpCreateDirectoryW(hConnect, lpwzDirectory);
503 HeapFree(GetProcessHeap(), 0, lpwzDirectory);
504 return ret;
505 }
506
507
508 static void AsyncFtpCreateDirectoryProc(WORKREQUEST *workRequest)
509 {
510 struct WORKREQ_FTPCREATEDIRECTORYW const *req = &workRequest->u.FtpCreateDirectoryW;
511 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
512
513 TRACE(" %p\n", lpwfs);
514
515 FTP_FtpCreateDirectoryW(lpwfs, req->lpszDirectory);
516 HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
517 }
518
519 /***********************************************************************
520 * FtpCreateDirectoryW (WININET.@)
521 *
522 * Create new directory on the FTP server
523 *
524 * RETURNS
525 * TRUE on success
526 * FALSE on failure
527 *
528 */
529 BOOL WINAPI FtpCreateDirectoryW(HINTERNET hConnect, LPCWSTR lpszDirectory)
530 {
531 LPWININETFTPSESSIONW lpwfs;
532 LPWININETAPPINFOW hIC = NULL;
533 BOOL r = FALSE;
534
535 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hConnect );
536 if (!lpwfs)
537 {
538 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
539 return FALSE;
540 }
541
542 if (WH_HFTPSESSION != lpwfs->hdr.htype)
543 {
544 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
545 goto lend;
546 }
547
548 if (lpwfs->download_in_progress != NULL)
549 {
550 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
551 goto lend;
552 }
553
554 if (!lpszDirectory)
555 {
556 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
557 goto lend;
558 }
559
560 hIC = lpwfs->lpAppInfo;
561 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
562 {
563 WORKREQUEST workRequest;
564 struct WORKREQ_FTPCREATEDIRECTORYW *req;
565
566 workRequest.asyncproc = AsyncFtpCreateDirectoryProc;
567 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
568 req = &workRequest.u.FtpCreateDirectoryW;
569 req->lpszDirectory = WININET_strdupW(lpszDirectory);
570
571 r = INTERNET_AsyncCall(&workRequest);
572 }
573 else
574 {
575 r = FTP_FtpCreateDirectoryW(lpwfs, lpszDirectory);
576 }
577 lend:
578 WININET_Release( &lpwfs->hdr );
579
580 return r;
581 }
582
583
584 /***********************************************************************
585 * FTP_FtpCreateDirectoryW (Internal)
586 *
587 * Create new directory on the FTP server
588 *
589 * RETURNS
590 * TRUE on success
591 * FALSE on failure
592 *
593 */
594 BOOL WINAPI FTP_FtpCreateDirectoryW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszDirectory)
595 {
596 INT nResCode;
597 BOOL bSuccess = FALSE;
598 LPWININETAPPINFOW hIC = NULL;
599
600 TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
601
602 /* Clear any error information */
603 INTERNET_SetLastError(0);
604
605 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_MKD, lpszDirectory, 0, 0, 0))
606 goto lend;
607
608 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
609 if (nResCode)
610 {
611 if (nResCode == 257)
612 bSuccess = TRUE;
613 else
614 FTP_SetResponseError(nResCode);
615 }
616
617 lend:
618 hIC = lpwfs->lpAppInfo;
619 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
620 {
621 INTERNET_ASYNC_RESULT iar;
622
623 iar.dwResult = (DWORD)bSuccess;
624 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
625 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
626 &iar, sizeof(INTERNET_ASYNC_RESULT));
627 }
628
629 return bSuccess;
630 }
631
632 /***********************************************************************
633 * FtpFindFirstFileA (WININET.@)
634 *
635 * Search the specified directory
636 *
637 * RETURNS
638 * HINTERNET on success
639 * NULL on failure
640 *
641 */
642 HINTERNET WINAPI FtpFindFirstFileA(HINTERNET hConnect,
643 LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
644 {
645 LPWSTR lpwzSearchFile;
646 WIN32_FIND_DATAW wfd;
647 LPWIN32_FIND_DATAW lpFindFileDataW;
648 HINTERNET ret;
649
650 lpwzSearchFile = lpszSearchFile?WININET_strdup_AtoW(lpszSearchFile):NULL;
651 lpFindFileDataW = lpFindFileData?&wfd:NULL;
652 ret = FtpFindFirstFileW(hConnect, lpwzSearchFile, lpFindFileDataW, dwFlags, dwContext);
653 HeapFree(GetProcessHeap(), 0, lpwzSearchFile);
654
655 if(lpFindFileData) {
656 WININET_find_data_WtoA(lpFindFileDataW, lpFindFileData);
657 }
658 return ret;
659 }
660
661
662 static void AsyncFtpFindFirstFileProc(WORKREQUEST *workRequest)
663 {
664 struct WORKREQ_FTPFINDFIRSTFILEW const *req = &workRequest->u.FtpFindFirstFileW;
665 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
666
667 TRACE("%p\n", lpwfs);
668
669 FTP_FtpFindFirstFileW(lpwfs, req->lpszSearchFile,
670 req->lpFindFileData, req->dwFlags, req->dwContext);
671 HeapFree(GetProcessHeap(), 0, req->lpszSearchFile);
672 }
673
674 /***********************************************************************
675 * FtpFindFirstFileW (WININET.@)
676 *
677 * Search the specified directory
678 *
679 * RETURNS
680 * HINTERNET on success
681 * NULL on failure
682 *
683 */
684 HINTERNET WINAPI FtpFindFirstFileW(HINTERNET hConnect,
685 LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
686 {
687 LPWININETFTPSESSIONW lpwfs;
688 LPWININETAPPINFOW hIC = NULL;
689 HINTERNET r = NULL;
690
691 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hConnect );
692 if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
693 {
694 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
695 goto lend;
696 }
697
698 if (lpwfs->download_in_progress != NULL)
699 {
700 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
701 goto lend;
702 }
703
704 hIC = lpwfs->lpAppInfo;
705 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
706 {
707 WORKREQUEST workRequest;
708 struct WORKREQ_FTPFINDFIRSTFILEW *req;
709
710 workRequest.asyncproc = AsyncFtpFindFirstFileProc;
711 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
712 req = &workRequest.u.FtpFindFirstFileW;
713 req->lpszSearchFile = (lpszSearchFile == NULL) ? NULL : WININET_strdupW(lpszSearchFile);
714 req->lpFindFileData = lpFindFileData;
715 req->dwFlags = dwFlags;
716 req->dwContext= dwContext;
717
718 INTERNET_AsyncCall(&workRequest);
719 r = NULL;
720 }
721 else
722 {
723 r = FTP_FtpFindFirstFileW(lpwfs, lpszSearchFile, lpFindFileData,
724 dwFlags, dwContext);
725 }
726 lend:
727 if( lpwfs )
728 WININET_Release( &lpwfs->hdr );
729
730 return r;
731 }
732
733
734 /***********************************************************************
735 * FTP_FtpFindFirstFileW (Internal)
736 *
737 * Search the specified directory
738 *
739 * RETURNS
740 * HINTERNET on success
741 * NULL on failure
742 *
743 */
744 HINTERNET WINAPI FTP_FtpFindFirstFileW(LPWININETFTPSESSIONW lpwfs,
745 LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
746 {
747 INT nResCode;
748 LPWININETAPPINFOW hIC = NULL;
749 HINTERNET hFindNext = NULL;
750
751 TRACE("\n");
752
753 /* Clear any error information */
754 INTERNET_SetLastError(0);
755
756 if (!FTP_InitListenSocket(lpwfs))
757 goto lend;
758
759 if (!FTP_SendType(lpwfs, INTERNET_FLAG_TRANSFER_ASCII))
760 goto lend;
761
762 if (!FTP_SendPortOrPasv(lpwfs))
763 goto lend;
764
765 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_LIST, NULL,
766 lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
767 goto lend;
768
769 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
770 if (nResCode)
771 {
772 if (nResCode == 125 || nResCode == 150)
773 {
774 INT nDataSocket;
775
776 /* Get data socket to server */
777 if (FTP_GetDataSocket(lpwfs, &nDataSocket))
778 {
779 hFindNext = FTP_ReceiveFileList(lpwfs, nDataSocket, lpszSearchFile, lpFindFileData, dwContext);
780 closesocket(nDataSocket);
781 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
782 if (nResCode != 226 && nResCode != 250)
783 INTERNET_SetLastError(ERROR_NO_MORE_FILES);
784 }
785 }
786 else
787 FTP_SetResponseError(nResCode);
788 }
789
790 lend:
791 if (lpwfs->lstnSocket != -1)
792 closesocket(lpwfs->lstnSocket);
793
794 hIC = lpwfs->lpAppInfo;
795 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
796 {
797 INTERNET_ASYNC_RESULT iar;
798
799 if (hFindNext)
800 {
801 iar.dwResult = (DWORD)hFindNext;
802 iar.dwError = ERROR_SUCCESS;
803 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
804 &iar, sizeof(INTERNET_ASYNC_RESULT));
805 }
806
807 iar.dwResult = (DWORD)hFindNext;
808 iar.dwError = hFindNext ? ERROR_SUCCESS : INTERNET_GetLastError();
809 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
810 &iar, sizeof(INTERNET_ASYNC_RESULT));
811 }
812
813 return hFindNext;
814 }
815
816
817 /***********************************************************************
818 * FtpGetCurrentDirectoryA (WININET.@)
819 *
820 * Retrieves the current directory
821 *
822 * RETURNS
823 * TRUE on success
824 * FALSE on failure
825 *
826 */
827 BOOL WINAPI FtpGetCurrentDirectoryA(HINTERNET hFtpSession, LPSTR lpszCurrentDirectory,
828 LPDWORD lpdwCurrentDirectory)
829 {
830 WCHAR *dir = NULL;
831 DWORD len;
832 BOOL ret;
833
834 if(lpdwCurrentDirectory) {
835 len = *lpdwCurrentDirectory;
836 if(lpszCurrentDirectory)
837 {
838 dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
839 if (NULL == dir)
840 {
841 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
842 return FALSE;
843 }
844 }
845 }
846 ret = FtpGetCurrentDirectoryW(hFtpSession, lpszCurrentDirectory?dir:NULL, lpdwCurrentDirectory?&len:NULL);
847
848 if (ret && lpszCurrentDirectory)
849 WideCharToMultiByte(CP_ACP, 0, dir, -1, lpszCurrentDirectory, len, NULL, NULL);
850
851 if (lpdwCurrentDirectory) *lpdwCurrentDirectory = len;
852 HeapFree(GetProcessHeap(), 0, dir);
853 return ret;
854 }
855
856
857 static void AsyncFtpGetCurrentDirectoryProc(WORKREQUEST *workRequest)
858 {
859 struct WORKREQ_FTPGETCURRENTDIRECTORYW const *req = &workRequest->u.FtpGetCurrentDirectoryW;
860 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
861
862 TRACE("%p\n", lpwfs);
863
864 FTP_FtpGetCurrentDirectoryW(lpwfs, req->lpszDirectory, req->lpdwDirectory);
865 }
866
867 /***********************************************************************
868 * FtpGetCurrentDirectoryW (WININET.@)
869 *
870 * Retrieves the current directory
871 *
872 * RETURNS
873 * TRUE on success
874 * FALSE on failure
875 *
876 */
877 BOOL WINAPI FtpGetCurrentDirectoryW(HINTERNET hFtpSession, LPWSTR lpszCurrentDirectory,
878 LPDWORD lpdwCurrentDirectory)
879 {
880 LPWININETFTPSESSIONW lpwfs;
881 LPWININETAPPINFOW hIC = NULL;
882 BOOL r = FALSE;
883
884 TRACE("len(%d)\n", *lpdwCurrentDirectory);
885
886 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hFtpSession );
887 if (NULL == lpwfs)
888 {
889 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
890 goto lend;
891 }
892
893 if (WH_HFTPSESSION != lpwfs->hdr.htype)
894 {
895 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
896 goto lend;
897 }
898
899 if (!lpdwCurrentDirectory)
900 {
901 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
902 goto lend;
903 }
904
905 if (lpszCurrentDirectory == NULL)
906 {
907 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
908 goto lend;
909 }
910
911 if (lpwfs->download_in_progress != NULL)
912 {
913 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
914 goto lend;
915 }
916
917 hIC = lpwfs->lpAppInfo;
918 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
919 {
920 WORKREQUEST workRequest;
921 struct WORKREQ_FTPGETCURRENTDIRECTORYW *req;
922
923 workRequest.asyncproc = AsyncFtpGetCurrentDirectoryProc;
924 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
925 req = &workRequest.u.FtpGetCurrentDirectoryW;
926 req->lpszDirectory = lpszCurrentDirectory;
927 req->lpdwDirectory = lpdwCurrentDirectory;
928
929 r = INTERNET_AsyncCall(&workRequest);
930 }
931 else
932 {
933 r = FTP_FtpGetCurrentDirectoryW(lpwfs, lpszCurrentDirectory,
934 lpdwCurrentDirectory);
935 }
936
937 lend:
938 if( lpwfs )
939 WININET_Release( &lpwfs->hdr );
940
941 return r;
942 }
943
944
945 /***********************************************************************
946 * FTP_FtpGetCurrentDirectoryW (Internal)
947 *
948 * Retrieves the current directory
949 *
950 * RETURNS
951 * TRUE on success
952 * FALSE on failure
953 *
954 */
955 BOOL WINAPI FTP_FtpGetCurrentDirectoryW(LPWININETFTPSESSIONW lpwfs, LPWSTR lpszCurrentDirectory,
956 LPDWORD lpdwCurrentDirectory)
957 {
958 INT nResCode;
959 LPWININETAPPINFOW hIC = NULL;
960 DWORD bSuccess = FALSE;
961
962 TRACE("len(%d)\n", *lpdwCurrentDirectory);
963
964 /* Clear any error information */
965 INTERNET_SetLastError(0);
966
967 hIC = lpwfs->lpAppInfo;
968 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PWD, NULL,
969 lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
970 goto lend;
971
972 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
973 if (nResCode)
974 {
975 if (nResCode == 257) /* Extract directory name */
976 {
977 DWORD firstpos, lastpos, len;
978 LPWSTR lpszResponseBuffer = WININET_strdup_AtoW(INTERNET_GetResponseBuffer());
979
980 for (firstpos = 0, lastpos = 0; lpszResponseBuffer[lastpos]; lastpos++)
981 {
982 if ('"' == lpszResponseBuffer[lastpos])
983 {
984 if (!firstpos)
985 firstpos = lastpos;
986 else
987 break;
988 }
989 }
990 len = lastpos - firstpos;
991 if (*lpdwCurrentDirectory >= len)
992 {
993 memcpy(lpszCurrentDirectory, &lpszResponseBuffer[firstpos + 1], len * sizeof(WCHAR));
994 lpszCurrentDirectory[len - 1] = 0;
995 *lpdwCurrentDirectory = len;
996 bSuccess = TRUE;
997 }
998 else INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
999
1000 HeapFree(GetProcessHeap(), 0, lpszResponseBuffer);
1001 }
1002 else
1003 FTP_SetResponseError(nResCode);
1004 }
1005
1006 lend:
1007 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1008 {
1009 INTERNET_ASYNC_RESULT iar;
1010
1011 iar.dwResult = (DWORD)bSuccess;
1012 iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
1013 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1014 &iar, sizeof(INTERNET_ASYNC_RESULT));
1015 }
1016
1017 return (DWORD) bSuccess;
1018 }
1019
1020 /***********************************************************************
1021 * FtpOpenFileA (WININET.@)
1022 *
1023 * Open a remote file for writing or reading
1024 *
1025 * RETURNS
1026 * HINTERNET handle on success
1027 * NULL on failure
1028 *
1029 */
1030 HINTERNET WINAPI FtpOpenFileA(HINTERNET hFtpSession,
1031 LPCSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1032 DWORD_PTR dwContext)
1033 {
1034 LPWSTR lpwzFileName;
1035 HINTERNET ret;
1036
1037 lpwzFileName = lpszFileName?WININET_strdup_AtoW(lpszFileName):NULL;
1038 ret = FtpOpenFileW(hFtpSession, lpwzFileName, fdwAccess, dwFlags, dwContext);
1039 HeapFree(GetProcessHeap(), 0, lpwzFileName);
1040 return ret;
1041 }
1042
1043
1044 static void AsyncFtpOpenFileProc(WORKREQUEST *workRequest)
1045 {
1046 struct WORKREQ_FTPOPENFILEW const *req = &workRequest->u.FtpOpenFileW;
1047 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
1048
1049 TRACE("%p\n", lpwfs);
1050
1051 FTP_FtpOpenFileW(lpwfs, req->lpszFilename,
1052 req->dwAccess, req->dwFlags, req->dwContext);
1053 HeapFree(GetProcessHeap(), 0, req->lpszFilename);
1054 }
1055
1056 /***********************************************************************
1057 * FtpOpenFileW (WININET.@)
1058 *
1059 * Open a remote file for writing or reading
1060 *
1061 * RETURNS
1062 * HINTERNET handle on success
1063 * NULL on failure
1064 *
1065 */
1066 HINTERNET WINAPI FtpOpenFileW(HINTERNET hFtpSession,
1067 LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1068 DWORD_PTR dwContext)
1069 {
1070 LPWININETFTPSESSIONW lpwfs;
1071 LPWININETAPPINFOW hIC = NULL;
1072 HINTERNET r = NULL;
1073
1074 TRACE("(%p,%s,0x%08x,0x%08x,0x%08lx)\n", hFtpSession,
1075 debugstr_w(lpszFileName), fdwAccess, dwFlags, dwContext);
1076
1077 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hFtpSession );
1078 if (!lpwfs)
1079 {
1080 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1081 return FALSE;
1082 }
1083
1084 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1085 {
1086 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1087 goto lend;
1088 }
1089
1090 if ((!lpszFileName) ||
1091 ((fdwAccess != GENERIC_READ) && (fdwAccess != GENERIC_WRITE)) ||
1092 ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY))
1093 {
1094 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1095 goto lend;
1096 }
1097
1098 if (lpwfs->download_in_progress != NULL)
1099 {
1100 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1101 goto lend;
1102 }
1103
1104 hIC = lpwfs->lpAppInfo;
1105 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1106 {
1107 WORKREQUEST workRequest;
1108 struct WORKREQ_FTPOPENFILEW *req;
1109
1110 workRequest.asyncproc = AsyncFtpOpenFileProc;
1111 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1112 req = &workRequest.u.FtpOpenFileW;
1113 req->lpszFilename = WININET_strdupW(lpszFileName);
1114 req->dwAccess = fdwAccess;
1115 req->dwFlags = dwFlags;
1116 req->dwContext = dwContext;
1117
1118 INTERNET_AsyncCall(&workRequest);
1119 r = NULL;
1120 }
1121 else
1122 {
1123 r = FTP_FtpOpenFileW(lpwfs, lpszFileName, fdwAccess, dwFlags, dwContext);
1124 }
1125
1126 lend:
1127 WININET_Release( &lpwfs->hdr );
1128
1129 return r;
1130 }
1131
1132
1133 /***********************************************************************
1134 * FTP_FtpOpenFileW (Internal)
1135 *
1136 * Open a remote file for writing or reading
1137 *
1138 * RETURNS
1139 * HINTERNET handle on success
1140 * NULL on failure
1141 *
1142 */
1143 HINTERNET FTP_FtpOpenFileW(LPWININETFTPSESSIONW lpwfs,
1144 LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1145 DWORD_PTR dwContext)
1146 {
1147 INT nDataSocket;
1148 BOOL bSuccess = FALSE;
1149 LPWININETFTPFILE lpwh = NULL;
1150 LPWININETAPPINFOW hIC = NULL;
1151 HINTERNET handle = NULL;
1152
1153 TRACE("\n");
1154
1155 /* Clear any error information */
1156 INTERNET_SetLastError(0);
1157
1158 if (GENERIC_READ == fdwAccess)
1159 {
1160 /* Set up socket to retrieve data */
1161 bSuccess = FTP_SendRetrieve(lpwfs, lpszFileName, dwFlags);
1162 }
1163 else if (GENERIC_WRITE == fdwAccess)
1164 {
1165 /* Set up socket to send data */
1166 bSuccess = FTP_SendStore(lpwfs, lpszFileName, dwFlags);
1167 }
1168
1169 /* Get data socket to server */
1170 if (bSuccess && FTP_GetDataSocket(lpwfs, &nDataSocket))
1171 {
1172 lpwh = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETFTPFILE));
1173 lpwh->hdr.htype = WH_HFILE;
1174 lpwh->hdr.dwFlags = dwFlags;
1175 lpwh->hdr.dwContext = dwContext;
1176 lpwh->hdr.dwRefCount = 1;
1177 lpwh->hdr.close_connection = NULL;
1178 lpwh->hdr.destroy = FTP_CloseFileTransferHandle;
1179 lpwh->hdr.lpfnStatusCB = lpwfs->hdr.lpfnStatusCB;
1180 lpwh->nDataSocket = nDataSocket;
1181 lpwh->session_deleted = FALSE;
1182
1183 WININET_AddRef( &lpwfs->hdr );
1184 lpwh->lpFtpSession = lpwfs;
1185 list_add_head( &lpwfs->hdr.children, &lpwh->hdr.entry );
1186
1187 handle = WININET_AllocHandle( &lpwh->hdr );
1188 if( !handle )
1189 goto lend;
1190
1191 /* Indicate that a download is currently in progress */
1192 lpwfs->download_in_progress = lpwh;
1193 }
1194
1195 if (lpwfs->lstnSocket != -1)
1196 closesocket(lpwfs->lstnSocket);
1197
1198 hIC = lpwfs->lpAppInfo;
1199 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1200 {
1201 INTERNET_ASYNC_RESULT iar;
1202
1203 if (lpwh)
1204 {
1205 iar.dwResult = (DWORD)handle;
1206 iar.dwError = ERROR_SUCCESS;
1207 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
1208 &iar, sizeof(INTERNET_ASYNC_RESULT));
1209 }
1210
1211 iar.dwResult = (DWORD)bSuccess;
1212 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1213 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1214 &iar, sizeof(INTERNET_ASYNC_RESULT));
1215 }
1216
1217 lend:
1218 if( lpwh )
1219 WININET_Release( &lpwh->hdr );
1220
1221 return handle;
1222 }
1223
1224
1225 /***********************************************************************
1226 * FtpGetFileA (WININET.@)
1227 *
1228 * Retrieve file from the FTP server
1229 *
1230 * RETURNS
1231 * TRUE on success
1232 * FALSE on failure
1233 *
1234 */
1235 BOOL WINAPI FtpGetFileA(HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile,
1236 BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1237 DWORD_PTR dwContext)
1238 {
1239 LPWSTR lpwzRemoteFile;
1240 LPWSTR lpwzNewFile;
1241 BOOL ret;
1242
1243 lpwzRemoteFile = lpszRemoteFile?WININET_strdup_AtoW(lpszRemoteFile):NULL;
1244 lpwzNewFile = lpszNewFile?WININET_strdup_AtoW(lpszNewFile):NULL;
1245 ret = FtpGetFileW(hInternet, lpwzRemoteFile, lpwzNewFile, fFailIfExists,
1246 dwLocalFlagsAttribute, dwInternetFlags, dwContext);
1247 HeapFree(GetProcessHeap(), 0, lpwzRemoteFile);
1248 HeapFree(GetProcessHeap(), 0, lpwzNewFile);
1249 return ret;
1250 }
1251
1252
1253 static void AsyncFtpGetFileProc(WORKREQUEST *workRequest)
1254 {
1255 struct WORKREQ_FTPGETFILEW const *req = &workRequest->u.FtpGetFileW;
1256 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
1257
1258 TRACE("%p\n", lpwfs);
1259
1260 FTP_FtpGetFileW(lpwfs, req->lpszRemoteFile,
1261 req->lpszNewFile, req->fFailIfExists,
1262 req->dwLocalFlagsAttribute, req->dwFlags, req->dwContext);
1263 HeapFree(GetProcessHeap(), 0, req->lpszRemoteFile);
1264 HeapFree(GetProcessHeap(), 0, req->lpszNewFile);
1265 }
1266
1267
1268 /***********************************************************************
1269 * FtpGetFileW (WININET.@)
1270 *
1271 * Retrieve file from the FTP server
1272 *
1273 * RETURNS
1274 * TRUE on success
1275 * FALSE on failure
1276 *
1277 */
1278 BOOL WINAPI FtpGetFileW(HINTERNET hInternet, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
1279 BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1280 DWORD_PTR dwContext)
1281 {
1282 LPWININETFTPSESSIONW lpwfs;
1283 LPWININETAPPINFOW hIC = NULL;
1284 BOOL r = FALSE;
1285
1286 if (!lpszRemoteFile || !lpszNewFile)
1287 {
1288 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1289 return FALSE;
1290 }
1291
1292 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hInternet );
1293 if (!lpwfs)
1294 {
1295 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1296 return FALSE;
1297 }
1298
1299 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1300 {
1301 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1302 goto lend;
1303 }
1304
1305 if ((dwInternetFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
1306 {
1307 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1308 goto lend;
1309 }
1310
1311 if (lpwfs->download_in_progress != NULL)
1312 {
1313 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1314 goto lend;
1315 }
1316
1317 hIC = lpwfs->lpAppInfo;
1318 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1319 {
1320 WORKREQUEST workRequest;
1321 struct WORKREQ_FTPGETFILEW *req;
1322
1323 workRequest.asyncproc = AsyncFtpGetFileProc;
1324 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1325 req = &workRequest.u.FtpGetFileW;
1326 req->lpszRemoteFile = WININET_strdupW(lpszRemoteFile);
1327 req->lpszNewFile = WININET_strdupW(lpszNewFile);
1328 req->dwLocalFlagsAttribute = dwLocalFlagsAttribute;
1329 req->fFailIfExists = fFailIfExists;
1330 req->dwFlags = dwInternetFlags;
1331 req->dwContext = dwContext;
1332
1333 r = INTERNET_AsyncCall(&workRequest);
1334 }
1335 else
1336 {
1337 r = FTP_FtpGetFileW(lpwfs, lpszRemoteFile, lpszNewFile,
1338 fFailIfExists, dwLocalFlagsAttribute, dwInternetFlags, dwContext);
1339 }
1340
1341 lend:
1342 WININET_Release( &lpwfs->hdr );
1343
1344 return r;
1345 }
1346
1347
1348 /***********************************************************************
1349 * FTP_FtpGetFileW (Internal)
1350 *
1351 * Retrieve file from the FTP server
1352 *
1353 * RETURNS
1354 * TRUE on success
1355 * FALSE on failure
1356 *
1357 */
1358 BOOL WINAPI FTP_FtpGetFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
1359 BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1360 DWORD_PTR dwContext)
1361 {
1362 BOOL bSuccess = FALSE;
1363 HANDLE hFile;
1364 LPWININETAPPINFOW hIC = NULL;
1365
1366 TRACE("lpszRemoteFile(%s) lpszNewFile(%s)\n", debugstr_w(lpszRemoteFile), debugstr_w(lpszNewFile));
1367
1368 /* Clear any error information */
1369 INTERNET_SetLastError(0);
1370
1371 /* Ensure we can write to lpszNewfile by opening it */
1372 hFile = CreateFileW(lpszNewFile, GENERIC_WRITE, 0, 0, fFailIfExists ?
1373 CREATE_NEW : CREATE_ALWAYS, dwLocalFlagsAttribute, 0);
1374 if (INVALID_HANDLE_VALUE == hFile)
1375 return FALSE;
1376
1377 /* Set up socket to retrieve data */
1378 if (FTP_SendRetrieve(lpwfs, lpszRemoteFile, dwInternetFlags))
1379 {
1380 INT nDataSocket;
1381
1382 /* Get data socket to server */
1383 if (FTP_GetDataSocket(lpwfs, &nDataSocket))
1384 {
1385 INT nResCode;
1386
1387 /* Receive data */
1388 FTP_RetrieveFileData(lpwfs, nDataSocket, hFile);
1389 closesocket(nDataSocket);
1390
1391 nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
1392 if (nResCode)
1393 {
1394 if (nResCode == 226)
1395 bSuccess = TRUE;
1396 else
1397 FTP_SetResponseError(nResCode);
1398 }
1399 }
1400 }
1401
1402 if (lpwfs->lstnSocket != -1)
1403 closesocket(lpwfs->lstnSocket);
1404
1405 CloseHandle(hFile);
1406
1407 hIC = lpwfs->lpAppInfo;
1408 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1409 {
1410 INTERNET_ASYNC_RESULT iar;
1411
1412 iar.dwResult = (DWORD)bSuccess;
1413 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1414 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1415 &iar, sizeof(INTERNET_ASYNC_RESULT));
1416 }
1417
1418 return bSuccess;
1419 }
1420
1421 /***********************************************************************
1422 * FtpGetFileSize (WININET.@)
1423 */
1424 DWORD WINAPI FtpGetFileSize( HINTERNET hFile, LPDWORD lpdwFileSizeHigh )
1425 {
1426 FIXME("(%p, %p)\n", hFile, lpdwFileSizeHigh);
1427
1428 if (lpdwFileSizeHigh)
1429 *lpdwFileSizeHigh = 0;
1430
1431 return 0;
1432 }
1433
1434 /***********************************************************************
1435 * FtpDeleteFileA (WININET.@)
1436 *
1437 * Delete a file on the ftp server
1438 *
1439 * RETURNS
1440 * TRUE on success
1441 * FALSE on failure
1442 *
1443 */
1444 BOOL WINAPI FtpDeleteFileA(HINTERNET hFtpSession, LPCSTR lpszFileName)
1445 {
1446 LPWSTR lpwzFileName;
1447 BOOL ret;
1448
1449 lpwzFileName = lpszFileName?WININET_strdup_AtoW(lpszFileName):NULL;
1450 ret = FtpDeleteFileW(hFtpSession, lpwzFileName);
1451 HeapFree(GetProcessHeap(), 0, lpwzFileName);
1452 return ret;
1453 }
1454
1455 static void AsyncFtpDeleteFileProc(WORKREQUEST *workRequest)
1456 {
1457 struct WORKREQ_FTPDELETEFILEW const *req = &workRequest->u.FtpDeleteFileW;
1458 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
1459
1460 TRACE("%p\n", lpwfs);
1461
1462 FTP_FtpDeleteFileW(lpwfs, req->lpszFilename);
1463 HeapFree(GetProcessHeap(), 0, req->lpszFilename);
1464 }
1465
1466 /***********************************************************************
1467 * FtpDeleteFileW (WININET.@)
1468 *
1469 * Delete a file on the ftp server
1470 *
1471 * RETURNS
1472 * TRUE on success
1473 * FALSE on failure
1474 *
1475 */
1476 BOOL WINAPI FtpDeleteFileW(HINTERNET hFtpSession, LPCWSTR lpszFileName)
1477 {
1478 LPWININETFTPSESSIONW lpwfs;
1479 LPWININETAPPINFOW hIC = NULL;
1480 BOOL r = FALSE;
1481
1482 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hFtpSession );
1483 if (!lpwfs)
1484 {
1485 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1486 return FALSE;
1487 }
1488
1489 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1490 {
1491 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1492 goto lend;
1493 }
1494
1495 if (lpwfs->download_in_progress != NULL)
1496 {
1497 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1498 goto lend;
1499 }
1500
1501 if (!lpszFileName)
1502 {
1503 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1504 goto lend;
1505 }
1506
1507 hIC = lpwfs->lpAppInfo;
1508 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1509 {
1510 WORKREQUEST workRequest;
1511 struct WORKREQ_FTPDELETEFILEW *req;
1512
1513 workRequest.asyncproc = AsyncFtpDeleteFileProc;
1514 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1515 req = &workRequest.u.FtpDeleteFileW;
1516 req->lpszFilename = WININET_strdupW(lpszFileName);
1517
1518 r = INTERNET_AsyncCall(&workRequest);
1519 }
1520 else
1521 {
1522 r = FTP_FtpDeleteFileW(lpwfs, lpszFileName);
1523 }
1524
1525 lend:
1526 WININET_Release( &lpwfs->hdr );
1527
1528 return r;
1529 }
1530
1531 /***********************************************************************
1532 * FTP_FtpDeleteFileW (Internal)
1533 *
1534 * Delete a file on the ftp server
1535 *
1536 * RETURNS
1537 * TRUE on success
1538 * FALSE on failure
1539 *
1540 */
1541 BOOL FTP_FtpDeleteFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszFileName)
1542 {
1543 INT nResCode;
1544 BOOL bSuccess = FALSE;
1545 LPWININETAPPINFOW hIC = NULL;
1546
1547 TRACE("%p\n", lpwfs);
1548
1549 /* Clear any error information */
1550 INTERNET_SetLastError(0);
1551
1552 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_DELE, lpszFileName, 0, 0, 0))
1553 goto lend;
1554
1555 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1556 if (nResCode)
1557 {
1558 if (nResCode == 250)
1559 bSuccess = TRUE;
1560 else
1561 FTP_SetResponseError(nResCode);
1562 }
1563 lend:
1564 hIC = lpwfs->lpAppInfo;
1565 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1566 {
1567 INTERNET_ASYNC_RESULT iar;
1568
1569 iar.dwResult = (DWORD)bSuccess;
1570 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1571 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1572 &iar, sizeof(INTERNET_ASYNC_RESULT));
1573 }
1574
1575 return bSuccess;
1576 }
1577
1578
1579 /***********************************************************************
1580 * FtpRemoveDirectoryA (WININET.@)
1581 *
1582 * Remove a directory on the ftp server
1583 *
1584 * RETURNS
1585 * TRUE on success
1586 * FALSE on failure
1587 *
1588 */
1589 BOOL WINAPI FtpRemoveDirectoryA(HINTERNET hFtpSession, LPCSTR lpszDirectory)
1590 {
1591 LPWSTR lpwzDirectory;
1592 BOOL ret;
1593
1594 lpwzDirectory = lpszDirectory?WININET_strdup_AtoW(lpszDirectory):NULL;
1595 ret = FtpRemoveDirectoryW(hFtpSession, lpwzDirectory);
1596 HeapFree(GetProcessHeap(), 0, lpwzDirectory);
1597 return ret;
1598 }
1599
1600 static void AsyncFtpRemoveDirectoryProc(WORKREQUEST *workRequest)
1601 {
1602 struct WORKREQ_FTPREMOVEDIRECTORYW const *req = &workRequest->u.FtpRemoveDirectoryW;
1603 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
1604
1605 TRACE("%p\n", lpwfs);
1606
1607 FTP_FtpRemoveDirectoryW(lpwfs, req->lpszDirectory);
1608 HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
1609 }
1610
1611 /***********************************************************************
1612 * FtpRemoveDirectoryW (WININET.@)
1613 *
1614 * Remove a directory on the ftp server
1615 *
1616 * RETURNS
1617 * TRUE on success
1618 * FALSE on failure
1619 *
1620 */
1621 BOOL WINAPI FtpRemoveDirectoryW(HINTERNET hFtpSession, LPCWSTR lpszDirectory)
1622 {
1623 LPWININETFTPSESSIONW lpwfs;
1624 LPWININETAPPINFOW hIC = NULL;
1625 BOOL r = FALSE;
1626
1627 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hFtpSession );
1628 if (!lpwfs)
1629 {
1630 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1631 return FALSE;
1632 }
1633
1634 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1635 {
1636 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1637 goto lend;
1638 }
1639
1640 if (lpwfs->download_in_progress != NULL)
1641 {
1642 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1643 goto lend;
1644 }
1645
1646 if (!lpszDirectory)
1647 {
1648 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1649 goto lend;
1650 }
1651
1652 hIC = lpwfs->lpAppInfo;
1653 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1654 {
1655 WORKREQUEST workRequest;
1656 struct WORKREQ_FTPREMOVEDIRECTORYW *req;
1657
1658 workRequest.asyncproc = AsyncFtpRemoveDirectoryProc;
1659 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1660 req = &workRequest.u.FtpRemoveDirectoryW;
1661 req->lpszDirectory = WININET_strdupW(lpszDirectory);
1662
1663 r = INTERNET_AsyncCall(&workRequest);
1664 }
1665 else
1666 {
1667 r = FTP_FtpRemoveDirectoryW(lpwfs, lpszDirectory);
1668 }
1669
1670 lend:
1671 WININET_Release( &lpwfs->hdr );
1672
1673 return r;
1674 }
1675
1676 /***********************************************************************
1677 * FTP_FtpRemoveDirectoryW (Internal)
1678 *
1679 * Remove a directory on the ftp server
1680 *
1681 * RETURNS
1682 * TRUE on success
1683 * FALSE on failure
1684 *
1685 */
1686 BOOL FTP_FtpRemoveDirectoryW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszDirectory)
1687 {
1688 INT nResCode;
1689 BOOL bSuccess = FALSE;
1690 LPWININETAPPINFOW hIC = NULL;
1691
1692 TRACE("\n");
1693
1694 /* Clear any error information */
1695 INTERNET_SetLastError(0);
1696
1697 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RMD, lpszDirectory, 0, 0, 0))
1698 goto lend;
1699
1700 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1701 if (nResCode)
1702 {
1703 if (nResCode == 250)
1704 bSuccess = TRUE;
1705 else
1706 FTP_SetResponseError(nResCode);
1707 }
1708
1709 lend:
1710 hIC = lpwfs->lpAppInfo;
1711 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1712 {
1713 INTERNET_ASYNC_RESULT iar;
1714
1715 iar.dwResult = (DWORD)bSuccess;
1716 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1717 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1718 &iar, sizeof(INTERNET_ASYNC_RESULT));
1719 }
1720
1721 return bSuccess;
1722 }
1723
1724
1725 /***********************************************************************
1726 * FtpRenameFileA (WININET.@)
1727 *
1728 * Rename a file on the ftp server
1729 *
1730 * RETURNS
1731 * TRUE on success
1732 * FALSE on failure
1733 *
1734 */
1735 BOOL WINAPI FtpRenameFileA(HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest)
1736 {
1737 LPWSTR lpwzSrc;
1738 LPWSTR lpwzDest;
1739 BOOL ret;
1740
1741 lpwzSrc = lpszSrc?WININET_strdup_AtoW(lpszSrc):NULL;
1742 lpwzDest = lpszDest?WININET_strdup_AtoW(lpszDest):NULL;
1743 ret = FtpRenameFileW(hFtpSession, lpwzSrc, lpwzDest);
1744 HeapFree(GetProcessHeap(), 0, lpwzSrc);
1745 HeapFree(GetProcessHeap(), 0, lpwzDest);
1746 return ret;
1747 }
1748
1749 static void AsyncFtpRenameFileProc(WORKREQUEST *workRequest)
1750 {
1751 struct WORKREQ_FTPRENAMEFILEW const *req = &workRequest->u.FtpRenameFileW;
1752 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest->hdr;
1753
1754 TRACE("%p\n", lpwfs);
1755
1756 FTP_FtpRenameFileW(lpwfs, req->lpszSrcFile, req->lpszDestFile);
1757 HeapFree(GetProcessHeap(), 0, req->lpszSrcFile);
1758 HeapFree(GetProcessHeap(), 0, req->lpszDestFile);
1759 }
1760
1761 /***********************************************************************
1762 * FtpRenameFileW (WININET.@)
1763 *
1764 * Rename a file on the ftp server
1765 *
1766 * RETURNS
1767 * TRUE on success
1768 * FALSE on failure
1769 *
1770 */
1771 BOOL WINAPI FtpRenameFileW(HINTERNET hFtpSession, LPCWSTR lpszSrc, LPCWSTR lpszDest)
1772 {
1773 LPWININETFTPSESSIONW lpwfs;
1774 LPWININETAPPINFOW hIC = NULL;
1775 BOOL r = FALSE;
1776
1777 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hFtpSession );
1778 if (!lpwfs)
1779 {
1780 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1781 return FALSE;
1782 }
1783
1784 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1785 {
1786 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1787 goto lend;
1788 }
1789
1790 if (lpwfs->download_in_progress != NULL)
1791 {
1792 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1793 goto lend;
1794 }
1795
1796 if (!lpszSrc || !lpszDest)
1797 {
1798 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1799 goto lend;
1800 }
1801
1802 hIC = lpwfs->lpAppInfo;
1803 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1804 {
1805 WORKREQUEST workRequest;
1806 struct WORKREQ_FTPRENAMEFILEW *req;
1807
1808 workRequest.asyncproc = AsyncFtpRenameFileProc;
1809 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1810 req = &workRequest.u.FtpRenameFileW;
1811 req->lpszSrcFile = WININET_strdupW(lpszSrc);
1812 req->lpszDestFile = WININET_strdupW(lpszDest);
1813
1814 r = INTERNET_AsyncCall(&workRequest);
1815 }
1816 else
1817 {
1818 r = FTP_FtpRenameFileW(lpwfs, lpszSrc, lpszDest);
1819 }
1820
1821 lend:
1822 WININET_Release( &lpwfs->hdr );
1823
1824 return r;
1825 }
1826
1827 /***********************************************************************
1828 * FTP_FtpRenameFileW (Internal)
1829 *
1830 * Rename a file on the ftp server
1831 *
1832 * RETURNS
1833 * TRUE on success
1834 * FALSE on failure
1835 *
1836 */
1837 BOOL FTP_FtpRenameFileW( LPWININETFTPSESSIONW lpwfs,
1838 LPCWSTR lpszSrc, LPCWSTR lpszDest)
1839 {
1840 INT nResCode;
1841 BOOL bSuccess = FALSE;
1842 LPWININETAPPINFOW hIC = NULL;
1843
1844 TRACE("\n");
1845
1846 /* Clear any error information */
1847 INTERNET_SetLastError(0);
1848
1849 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNFR, lpszSrc, 0, 0, 0))
1850 goto lend;
1851
1852 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1853 if (nResCode == 350)
1854 {
1855 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNTO, lpszDest, 0, 0, 0))
1856 goto lend;
1857
1858 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1859 }
1860
1861 if (nResCode == 250)
1862 bSuccess = TRUE;
1863 else
1864 FTP_SetResponseError(nResCode);
1865
1866 lend:
1867 hIC = lpwfs->lpAppInfo;
1868 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1869 {
1870 INTERNET_ASYNC_RESULT iar;
1871
1872 iar.dwResult = (DWORD)bSuccess;
1873 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1874 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1875 &iar, sizeof(INTERNET_ASYNC_RESULT));
1876 }
1877
1878 return bSuccess;
1879 }
1880
1881 /***********************************************************************
1882 * FtpCommandA (WININET.@)
1883 */
1884 BOOL WINAPI FtpCommandA( HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags,
1885 LPCSTR lpszCommand, DWORD_PTR dwContext, HINTERNET* phFtpCommand )
1886 {
1887 BOOL r;
1888 WCHAR *cmdW;
1889
1890 TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
1891 debugstr_a(lpszCommand), dwContext, phFtpCommand);
1892
1893 if (fExpectResponse)
1894 {
1895 FIXME("data connection not supported\n");
1896 return FALSE;
1897 }
1898
1899 if (!lpszCommand || !lpszCommand[0])
1900 {
1901 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1902 return FALSE;
1903 }
1904
1905 if (!(cmdW = WININET_strdup_AtoW(lpszCommand)))
1906 {
1907 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1908 return FALSE;
1909 }
1910
1911 r = FtpCommandW(hConnect, fExpectResponse, dwFlags, cmdW, dwContext, phFtpCommand);
1912
1913 HeapFree(GetProcessHeap(), 0, cmdW);
1914 return r;
1915 }
1916
1917 /***********************************************************************
1918 * FtpCommandW (WININET.@)
1919 */
1920 BOOL WINAPI FtpCommandW( HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags,
1921 LPCWSTR lpszCommand, DWORD_PTR dwContext, HINTERNET* phFtpCommand )
1922 {
1923 BOOL r = FALSE;
1924 LPWININETFTPSESSIONW lpwfs;
1925 LPSTR cmd = NULL;
1926 DWORD len, nBytesSent= 0;
1927 INT nResCode, nRC = 0;
1928
1929 TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
1930 debugstr_w(lpszCommand), dwContext, phFtpCommand);
1931
1932 if (!lpszCommand || !lpszCommand[0])
1933 {
1934 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1935 return FALSE;
1936 }
1937
1938 if (fExpectResponse)
1939 {
1940 FIXME("data connection not supported\n");
1941 return FALSE;
1942 }
1943
1944 lpwfs = (LPWININETFTPSESSIONW) WININET_GetObject( hConnect );
1945 if (!lpwfs)
1946 {
1947 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1948 return FALSE;
1949 }
1950
1951 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1952 {
1953 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1954 goto lend;
1955 }
1956
1957 if (lpwfs->download_in_progress != NULL)
1958 {
1959 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1960 goto lend;
1961 }
1962
1963 len = WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, NULL, 0, NULL, NULL) + strlen(szCRLF);
1964 if ((cmd = HeapAlloc(GetProcessHeap(), 0, len )))
1965 WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, cmd, len, NULL, NULL);
1966 else
1967 {
1968 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1969 goto lend;
1970 }
1971
1972 strcat(cmd, szCRLF);
1973 len--;
1974
1975 TRACE("Sending (%s) len(%d)\n", cmd, len);
1976 while ((nBytesSent < len) && (nRC != -1))
1977 {
1978 nRC = send(lpwfs->sndSocket, cmd + nBytesSent, len - nBytesSent, 0);
1979 if (nRC != -1)
1980 {
1981 nBytesSent += nRC;
1982 TRACE("Sent %d bytes\n", nRC);
1983 }
1984 }
1985
1986 if (nBytesSent)
1987 {
1988 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1989 if (nResCode > 0 && nResCode < 400)
1990 r = TRUE;
1991 else
1992 FTP_SetResponseError(nResCode);
1993 }
1994
1995 lend:
1996 WININET_Release( &lpwfs->hdr );
1997 HeapFree(GetProcessHeap(), 0, cmd);
1998 return r;
1999 }
2000
2001 /***********************************************************************
2002 * FTP_Connect (internal)
2003 *
2004 * Connect to a ftp server
2005 *
2006 * RETURNS
2007 * HINTERNET a session handle on success
2008 * NULL on failure
2009 *
2010 * NOTES:
2011 *
2012 * Windows uses 'anonymous' as the username, when given a NULL username
2013 * and a NULL password. The password is first looked up in:
2014 *
2015 * HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\EmailName
2016 *
2017 * If this entry is not present it uses the current username as the password.
2018 *
2019 */
2020
2021 HINTERNET FTP_Connect(LPWININETAPPINFOW hIC, LPCWSTR lpszServerName,
2022 INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
2023 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
2024 DWORD dwInternalFlags)
2025 {
2026 static const WCHAR szKey[] = {'S','o','f','t','w','a','r','e','\\',
2027 'M','i','c','r','o','s','o','f','t','\\',
2028 'W','i','n','d','o','w','s','\\',
2029 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2030 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0};
2031 static const WCHAR szValue[] = {'E','m','a','i','l','N','a','m','e',0};
2032 static const WCHAR szDefaultUsername[] = {'a','n','o','n','y','m','o','u','s','\0'};
2033 static const WCHAR szEmpty[] = {'\0'};
2034 struct sockaddr_in socketAddr;
2035 INT nsocket = -1;
2036 UINT sock_namelen;
2037 BOOL bSuccess = FALSE;
2038 LPWININETFTPSESSIONW lpwfs = NULL;
2039 HINTERNET handle = NULL;
2040
2041 TRACE("%p Server(%s) Port(%d) User(%s) Paswd(%s)\n",
2042 hIC, debugstr_w(lpszServerName),
2043 nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword));
2044
2045 assert( hIC->hdr.htype == WH_HINIT );
2046
2047 if (NULL == lpszUserName && NULL != lpszPassword)
2048 {
2049 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2050 goto lerror;
2051 }
2052
2053 lpwfs = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETFTPSESSIONW));
2054 if (NULL == lpwfs)
2055 {
2056 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2057 goto lerror;
2058 }
2059
2060 if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
2061 nServerPort = INTERNET_DEFAULT_FTP_PORT;
2062
2063 lpwfs->hdr.htype = WH_HFTPSESSION;
2064 lpwfs->hdr.dwFlags = dwFlags;
2065 lpwfs->hdr.dwContext = dwContext;
2066 lpwfs->hdr.dwInternalFlags = dwInternalFlags;
2067 lpwfs->hdr.dwRefCount = 1;
2068 lpwfs->hdr.close_connection = FTP_CloseConnection;
2069 lpwfs->hdr.destroy = FTP_CloseSessionHandle;
2070 lpwfs->hdr.lpfnStatusCB = hIC->hdr.lpfnStatusCB;
2071 lpwfs->download_in_progress = NULL;
2072 lpwfs->sndSocket = -1;
2073 lpwfs->lstnSocket = -1;
2074 lpwfs->pasvSocket = -1;
2075
2076 WININET_AddRef( &hIC->hdr );
2077 lpwfs->lpAppInfo = hIC;
2078 list_add_head( &hIC->hdr.children, &lpwfs->hdr.entry );
2079
2080 handle = WININET_AllocHandle( &lpwfs->hdr );
2081 if( !handle )
2082 {
2083 ERR("Failed to alloc handle\n");
2084 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2085 goto lerror;
2086 }
2087
2088 if(hIC->lpszProxy && hIC->dwAccessType == INTERNET_OPEN_TYPE_PROXY) {
2089 if(strchrW(hIC->lpszProxy, ' '))
2090 FIXME("Several proxies not implemented.\n");
2091 if(hIC->lpszProxyBypass)
2092 FIXME("Proxy bypass is ignored.\n");
2093 }
2094 if ( !lpszUserName) {
2095 HKEY key;
2096 WCHAR szPassword[MAX_PATH];
2097 DWORD len = sizeof(szPassword);
2098
2099 lpwfs->lpszUserName = WININET_strdupW(szDefaultUsername);
2100
2101 RegOpenKeyW(HKEY_CURRENT_USER, szKey, &key);
2102 if (RegQueryValueExW(key, szValue, NULL, NULL, (LPBYTE)szPassword, &len)) {
2103 /* Nothing in the registry, get the username and use that as the password */
2104 if (!GetUserNameW(szPassword, &len)) {
2105 /* Should never get here, but use an empty password as failsafe */
2106 strcpyW(szPassword, szEmpty);
2107 }
2108 }
2109 RegCloseKey(key);
2110
2111 TRACE("Password used for anonymous ftp : (%s)\n", debugstr_w(szPassword));
2112 lpwfs->lpszPassword = WININET_strdupW(szPassword);
2113 }
2114 else {
2115 lpwfs->lpszUserName = WININET_strdupW(lpszUserName);
2116
2117 if (lpszPassword)
2118 lpwfs->lpszPassword = WININET_strdupW(lpszPassword);
2119 else
2120 lpwfs->lpszPassword = WININET_strdupW(szEmpty);
2121 }
2122
2123 /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
2124 if (!(lpwfs->hdr.dwInternalFlags & INET_OPENURL))
2125 {
2126 INTERNET_ASYNC_RESULT iar;
2127
2128 iar.dwResult = (DWORD)handle;
2129 iar.dwError = ERROR_SUCCESS;
2130
2131 SendAsyncCallback(&hIC->hdr, dwContext,
2132 INTERNET_STATUS_HANDLE_CREATED, &iar,
2133 sizeof(INTERNET_ASYNC_RESULT));
2134 }
2135
2136 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_RESOLVING_NAME,
2137 (LPWSTR) lpszServerName, strlenW(lpszServerName));
2138
2139 if (!GetAddress(lpszServerName, nServerPort, &socketAddr))
2140 {
2141 INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
2142 goto lerror;
2143 }
2144
2145 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_NAME_RESOLVED,
2146 (LPWSTR) lpszServerName, strlenW(lpszServerName));
2147
2148 nsocket = socket(AF_INET,SOCK_STREAM,0);
2149 if (nsocket == -1)
2150 {
2151 INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2152 goto lerror;
2153 }
2154
2155 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTING_TO_SERVER,
2156 &socketAddr, sizeof(struct sockaddr_in));
2157
2158 if (connect(nsocket, (struct sockaddr *)&socketAddr, sizeof(socketAddr)) < 0)
2159 {
2160 ERR("Unable to connect (%s)\n", strerror(errno));
2161 INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2162 }
2163 else
2164 {
2165 TRACE("Connected to server\n");
2166 lpwfs->sndSocket = nsocket;
2167 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTED_TO_SERVER,
2168 &socketAddr, sizeof(struct sockaddr_in));
2169
2170 sock_namelen = sizeof(lpwfs->socketAddress);
2171 getsockname(nsocket, (struct sockaddr *) &lpwfs->socketAddress, &sock_namelen);
2172
2173 if (FTP_ConnectToHost(lpwfs))
2174 {
2175 TRACE("Successfully logged into server\n");
2176 bSuccess = TRUE;
2177 }
2178 }
2179
2180 lerror:
2181 if (lpwfs) WININET_Release( &lpwfs->hdr );
2182
2183 if (!bSuccess && handle)
2184 {
2185 WININET_FreeHandle( handle );
2186 handle = NULL;
2187 }
2188
2189 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2190 {
2191 INTERNET_ASYNC_RESULT iar;
2192
2193 iar.dwResult = bSuccess ? (DWORD_PTR)lpwfs : 0;
2194 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
2195 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
2196 &iar, sizeof(INTERNET_ASYNC_RESULT));
2197 }
2198
2199 return handle;
2200 }
2201
2202
2203 /***********************************************************************
2204 * FTP_ConnectToHost (internal)
2205 *
2206 * Connect to a ftp server
2207 *
2208 * RETURNS
2209 * TRUE on success
2210 * NULL on failure
2211 *
2212 */
2213 static BOOL FTP_ConnectToHost(LPWININETFTPSESSIONW lpwfs)
2214 {
2215 INT nResCode;
2216 BOOL bSuccess = FALSE;
2217
2218 TRACE("\n");
2219 FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2220
2221 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_USER, lpwfs->lpszUserName, 0, 0, 0))
2222 goto lend;
2223
2224 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2225 if (nResCode)
2226 {
2227 /* Login successful... */
2228 if (nResCode == 230)
2229 bSuccess = TRUE;
2230 /* User name okay, need password... */
2231 else if (nResCode == 331)
2232 bSuccess = FTP_SendPassword(lpwfs);
2233 /* Need account for login... */
2234 else if (nResCode == 332)
2235 bSuccess = FTP_SendAccount(lpwfs);
2236 else
2237 FTP_SetResponseError(nResCode);
2238 }
2239
2240 TRACE("Returning %d\n", bSuccess);
2241 lend:
2242 return bSuccess;
2243 }
2244
2245
2246 /***********************************************************************
2247 * FTP_SendCommandA (internal)
2248 *
2249 * Send command to server
2250 *
2251 * RETURNS
2252 * TRUE on success
2253 * NULL on failure
2254 *
2255 */
2256 static BOOL FTP_SendCommandA(INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam,
2257 INTERNET_STATUS_CALLBACK lpfnStatusCB, LPWININETHANDLEHEADER hdr, DWORD_PTR dwContext)
2258 {
2259 DWORD len;
2260 CHAR *buf;
2261 DWORD nBytesSent = 0;
2262 int nRC = 0;
2263 DWORD dwParamLen;
2264
2265 TRACE("%d: (%s) %d\n", ftpCmd, lpszParam, nSocket);
2266
2267 if (lpfnStatusCB)
2268 {
2269 lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
2270 }
2271
2272 dwParamLen = lpszParam?strlen(lpszParam)+1:0;
2273 len = dwParamLen + strlen(szFtpCommands[ftpCmd]) + strlen(szCRLF);
2274 if (NULL == (buf = HeapAlloc(GetProcessHeap(), 0, len+1)))
2275 {
2276 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2277 return FALSE;
2278 }
2279 sprintf(buf, "%s%s%s%s", szFtpCommands[ftpCmd], dwParamLen ? " " : "",
2280 dwParamLen ? lpszParam : "", szCRLF);
2281
2282 TRACE("Sending (%s) len(%d)\n", buf, len);
2283 while((nBytesSent < len) && (nRC != -1))
2284 {
2285 nRC = send(nSocket, buf+nBytesSent, len - nBytesSent, 0);
2286 nBytesSent += nRC;
2287 }
2288
2289 HeapFree(GetProcessHeap(), 0, (LPVOID)buf);
2290
2291 if (lpfnStatusCB)
2292 {
2293 lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_REQUEST_SENT,
2294 &nBytesSent, sizeof(DWORD));
2295 }
2296
2297 TRACE("Sent %d bytes\n", nBytesSent);
2298 return (nRC != -1);
2299 }
2300
2301 /***********************************************************************
2302 * FTP_SendCommand (internal)
2303 *
2304 * Send command to server
2305 *
2306 * RETURNS
2307 * TRUE on success
2308 * NULL on failure
2309 *
2310 */
2311 static BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam,
2312 INTERNET_STATUS_CALLBACK lpfnStatusCB, LPWININETHANDLEHEADER hdr, DWORD_PTR dwContext)
2313 {
2314 BOOL ret;
2315 LPSTR lpszParamA = lpszParam?WININET_strdup_WtoA(lpszParam):NULL;
2316 ret = FTP_SendCommandA(nSocket, ftpCmd, lpszParamA, lpfnStatusCB, hdr, dwContext);
2317 HeapFree(GetProcessHeap(), 0, lpszParamA);
2318 return ret;
2319 }
2320
2321 /***********************************************************************
2322 * FTP_ReceiveResponse (internal)
2323 *
2324 * Receive response from server
2325 *
2326 * RETURNS
2327 * Reply code on success
2328 * 0 on failure
2329 *
2330 */
2331 INT FTP_ReceiveResponse(LPWININETFTPSESSIONW lpwfs, DWORD_PTR dwContext)
2332 {
2333 LPSTR lpszResponse = INTERNET_GetResponseBuffer();
2334 DWORD nRecv;
2335 INT rc = 0;
2336 char firstprefix[5];
2337 BOOL multiline = FALSE;
2338 LPWININETAPPINFOW hIC = NULL;
2339
2340 TRACE("socket(%d)\n", lpwfs->sndSocket);
2341
2342 hIC = lpwfs->lpAppInfo;
2343 SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2344
2345 while(1)
2346 {
2347 if (!INTERNET_GetNextLine(lpwfs->sndSocket, &nRecv))
2348 goto lerror;
2349
2350 if (nRecv >= 3)
2351 {
2352 if(!multiline)
2353 {
2354 if(lpszResponse[3] != '-')
2355 break;
2356 else
2357 { /* Start of multiline repsonse. Loop until we get "nnn " */
2358 multiline = TRUE;
2359 memcpy(firstprefix, lpszResponse, 3);
2360 firstprefix[3] = ' ';
2361 firstprefix[4] = '\0';
2362 }
2363 }
2364 else
2365 {
2366 if(!memcmp(firstprefix, lpszResponse, 4))
2367 break;
2368 }
2369 }
2370 }
2371
2372 if (nRecv >= 3)
2373 {
2374 rc = atoi(lpszResponse);
2375
2376 SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2377 &nRecv, sizeof(DWORD));
2378 }
2379
2380 lerror:
2381 TRACE("return %d\n", rc);
2382 return rc;
2383 }
2384
2385
2386 /***********************************************************************
2387 * FTP_SendPassword (internal)
2388 *
2389 * Send password to ftp server
2390 *
2391 * RETURNS
2392 * TRUE on success
2393 * NULL on failure
2394 *
2395 */
2396 static BOOL FTP_SendPassword(LPWININETFTPSESSIONW lpwfs)
2397 {
2398 INT nResCode;
2399 BOOL bSuccess = FALSE;
2400
2401 TRACE("\n");
2402 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASS, lpwfs->lpszPassword, 0, 0, 0))
2403 goto lend;
2404
2405 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2406 if (nResCode)
2407 {
2408 TRACE("Received reply code %d\n", nResCode);
2409 /* Login successful... */
2410 if (nResCode == 230)
2411 bSuccess = TRUE;
2412 /* Command not implemented, superfluous at the server site... */
2413 /* Need account for login... */
2414 else if (nResCode == 332)
2415 bSuccess = FTP_SendAccount(lpwfs);
2416 else
2417 FTP_SetResponseError(nResCode);
2418 }
2419
2420 lend:
2421 TRACE("Returning %d\n", bSuccess);
2422 return bSuccess;
2423 }
2424
2425
2426 /***********************************************************************
2427 * FTP_SendAccount (internal)
2428 *
2429 *
2430 *
2431 * RETURNS
2432 * TRUE on success
2433 * FALSE on failure
2434 *
2435 */
2436 static BOOL FTP_SendAccount(LPWININETFTPSESSIONW lpwfs)
2437 {
2438 INT nResCode;
2439 BOOL bSuccess = FALSE;
2440
2441 TRACE("\n");
2442 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_ACCT, szNoAccount, 0, 0, 0))
2443 goto lend;
2444
2445 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2446 if (nResCode)
2447 bSuccess = TRUE;
2448 else
2449 FTP_SetResponseError(nResCode);
2450
2451 lend:
2452 return bSuccess;
2453 }
2454
2455
2456 /***********************************************************************
2457 * FTP_SendStore (internal)
2458 *
2459 * Send request to upload file to ftp server
2460 *
2461 * RETURNS
2462 * TRUE on success
2463 * FALSE on failure
2464 *
2465 */
2466 static BOOL FTP_SendStore(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
2467 {
2468 INT nResCode;
2469 BOOL bSuccess = FALSE;
2470
2471 TRACE("\n");
2472 if (!FTP_InitListenSocket(lpwfs))
2473 goto lend;
2474
2475 if (!FTP_SendType(lpwfs, dwType))
2476 goto lend;
2477
2478 if (!FTP_SendPortOrPasv(lpwfs))
2479 goto lend;
2480
2481 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_STOR, lpszRemoteFile, 0, 0, 0))
2482 goto lend;
2483 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2484 if (nResCode)
2485 {
2486 if (nResCode == 150 || nResCode == 125)
2487 bSuccess = TRUE;
2488 else
2489 FTP_SetResponseError(nResCode);
2490 }
2491
2492 lend:
2493 if (!bSuccess && lpwfs->lstnSocket != -1)
2494 {
2495 closesocket(lpwfs->lstnSocket);
2496 lpwfs->lstnSocket = -1;
2497 }
2498
2499 return bSuccess;
2500 }
2501
2502
2503 /***********************************************************************
2504 * FTP_InitListenSocket (internal)
2505 *
2506 * Create a socket to listen for server response
2507 *
2508 * RETURNS
2509 * TRUE on success
2510 * FALSE on failure
2511 *
2512 */
2513 static BOOL FTP_InitListenSocket(LPWININETFTPSESSIONW lpwfs)
2514 {
2515 BOOL bSuccess = FALSE;
2516 socklen_t namelen = sizeof(struct sockaddr_in);
2517
2518 TRACE("\n");
2519
2520 lpwfs->lstnSocket = socket(PF_INET, SOCK_STREAM, 0);
2521 if (lpwfs->lstnSocket == -1)
2522 {
2523 TRACE("Unable to create listening socket\n");
2524 goto lend;
2525 }
2526
2527 /* We obtain our ip addr from the name of the command channel socket */
2528 lpwfs->lstnSocketAddress = lpwfs->socketAddress;
2529
2530 /* and get the system to assign us a port */
2531 lpwfs->lstnSocketAddress.sin_port = htons((u_short) 0);
2532
2533 if (bind(lpwfs->lstnSocket,(struct sockaddr *) &lpwfs->lstnSocketAddress, sizeof(struct sockaddr_in)) == -1)
2534 {
2535 TRACE("Unable to bind socket\n");
2536 goto lend;
2537 }
2538
2539 if (listen(lpwfs->lstnSocket, MAX_BACKLOG) == -1)
2540 {
2541 TRACE("listen failed\n");
2542 goto lend;
2543 }
2544
2545 if (getsockname(lpwfs->lstnSocket, (struct sockaddr *) &lpwfs->lstnSocketAddress, &namelen) != -1)
2546 bSuccess = TRUE;
2547
2548 lend:
2549 if (!bSuccess && lpwfs->lstnSocket != -1)
2550 {
2551 closesocket(lpwfs->lstnSocket);
2552 lpwfs->lstnSocket = -1;
2553 }
2554
2555 return bSuccess;
2556 }
2557
2558
2559 /***********************************************************************
2560 * FTP_SendType (internal)
2561 *
2562 * Tell server type of data being transferred
2563 *
2564 * RETURNS
2565 * TRUE on success
2566 * FALSE on failure
2567 *
2568 * W98SE doesn't cache the type that's currently set
2569 * (i.e. it sends it always),
2570 * so we probably don't want to do that either.
2571 */
2572 static BOOL FTP_SendType(LPWININETFTPSESSIONW lpwfs, DWORD dwType)
2573 {
2574 INT nResCode;
2575 WCHAR type[] = { 'I','\0' };
2576 BOOL bSuccess = FALSE;
2577
2578 TRACE("\n");
2579 if (dwType & INTERNET_FLAG_TRANSFER_ASCII)
2580 type[0] = 'A';
2581
2582 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_TYPE, type, 0, 0, 0))
2583 goto lend;
2584
2585 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext)/100;
2586 if (nResCode)
2587 {
2588 if (nResCode == 2)
2589 bSuccess = TRUE;
2590 else
2591 FTP_SetResponseError(nResCode);
2592 }
2593
2594 lend:
2595 return bSuccess;
2596 }
2597
2598
2599 #if 0 /* FIXME: should probably be used for FtpGetFileSize */
2600 /***********************************************************************
2601 * FTP_GetFileSize (internal)
2602 *
2603 * Retrieves from the server the size of the given file
2604 *
2605 * RETURNS
2606 * TRUE on success
2607 * FALSE on failure
2608 *
2609 */
2610 static BOOL FTP_GetFileSize(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD *dwSize)
2611 {
2612 INT nResCode;
2613 BOOL bSuccess = FALSE;
2614
2615 TRACE("\n");
2616
2617 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_SIZE, lpszRemoteFile, 0, 0, 0))
2618 goto lend;
2619
2620 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2621 if (nResCode)
2622 {
2623 if (nResCode == 213) {
2624 /* Now parses the output to get the actual file size */
2625 int i;
2626 LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
2627
2628 for (i = 0; (lpszResponseBuffer[i] != ' ') && (lpszResponseBuffer[i] != '\0'); i++) ;
2629 if (lpszResponseBuffer[i] == '\0') return FALSE;
2630 *dwSize = atol(&(lpszResponseBuffer[i + 1]));
2631
2632 bSuccess = TRUE;
2633 } else {
2634 FTP_SetResponseError(nResCode);
2635 }
2636 }
2637
2638 lend:
2639 return bSuccess;
2640 }
2641 #endif
2642
2643
2644 /***********************************************************************
2645 * FTP_SendPort (internal)
2646 *
2647 * Tell server which port to use
2648 *
2649 * RETURNS
2650 * TRUE on success
2651 * FALSE on failure
2652 *
2653 */
2654 static BOOL FTP_SendPort(LPWININETFTPSESSIONW lpwfs)
2655 {
2656 static const WCHAR szIPFormat[] = {'%','d',',','%','d',',','%','d',',','%','d',',','%','d',',','%','d','\0'};
2657 INT nResCode;
2658 WCHAR szIPAddress[64];
2659 BOOL bSuccess = FALSE;
2660 TRACE("\n");
2661
2662 sprintfW(szIPAddress, szIPFormat,
2663 lpwfs->lstnSocketAddress.sin_addr.s_addr&0x000000FF,
2664 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x0000FF00)>>8,
2665 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x00FF0000)>>16,
2666 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0xFF000000)>>24,
2667 lpwfs->lstnSocketAddress.sin_port & 0xFF,
2668 (lpwfs->lstnSocketAddress.sin_port & 0xFF00)>>8);
2669
2670 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PORT, szIPAddress, 0, 0, 0))
2671 goto lend;
2672
2673 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2674 if (nResCode)
2675 {
2676 if (nResCode == 200)
2677 bSuccess = TRUE;
2678 else
2679 FTP_SetResponseError(nResCode);
2680 }
2681
2682 lend:
2683 return bSuccess;
2684 }
2685
2686
2687 /***********************************************************************
2688 * FTP_DoPassive (internal)
2689 *
2690 * Tell server that we want to do passive transfers
2691 * and connect data socket
2692 *
2693 * RETURNS
2694 * TRUE on success
2695 * FALSE on failure
2696 *
2697 */
2698 static BOOL FTP_DoPassive(LPWININETFTPSESSIONW lpwfs)
2699 {
2700 INT nResCode;
2701 BOOL bSuccess = FALSE;
2702
2703 TRACE("\n");
2704 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASV, NULL, 0, 0, 0))
2705 goto lend;
2706
2707 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2708 if (nResCode)
2709 {
2710 if (nResCode == 227)
2711 {
2712 LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
2713 LPSTR p;
2714 int f[6];
2715 int i;
2716 char *pAddr, *pPort;
2717 INT nsocket = -1;
2718 struct sockaddr_in dataSocketAddress;
2719
2720 p = lpszResponseBuffer+4; /* skip status code */
2721 while (*p != '\0' && (*p < '0' || *p > '9')) p++;
2722
2723 if (*p == '\0')
2724 {
2725 ERR("no address found in response, aborting\n");
2726 goto lend;
2727 }
2728
2729 if (sscanf(p, "%d,%d,%d,%d,%d,%d", &f[0], &f[1], &f[2], &f[3],
2730 &f[4], &f[5]) != 6)
2731 {
2732 ERR("unknown response address format '%s', aborting\n", p);
2733 goto lend;
2734 }
2735 for (i=0; i < 6; i++)
2736 f[i] = f[i] & 0xff;
2737
2738 dataSocketAddress = lpwfs->socketAddress;
2739 pAddr = (char *)&(dataSocketAddress.sin_addr.s_addr);
2740 pPort = (char *)&(dataSocketAddress.sin_port);
2741 pAddr[0] = f[0];
2742 pAddr[1] = f[1];
2743 pAddr[2] = f[2];
2744 pAddr[3] = f[3];
2745 pPort[0] = f[4];
2746 pPort[1] = f[5];
2747
2748 nsocket = socket(AF_INET,SOCK_STREAM,0);
2749 if (nsocket == -1)
2750 goto lend;
2751
2752 if (connect(nsocket, (struct sockaddr *)&dataSocketAddress, sizeof(dataSocketAddress)))
2753 {
2754 ERR("can't connect passive FTP data port.\n");
2755 closesocket(nsocket);
2756 goto lend;
2757 }
2758 lpwfs->pasvSocket = nsocket;
2759 bSuccess = TRUE;
2760 }
2761 else
2762 FTP_SetResponseError(nResCode);
2763 }
2764
2765 lend:
2766 return bSuccess;
2767 }
2768
2769
2770 static BOOL FTP_SendPortOrPasv(LPWININETFTPSESSIONW lpwfs)
2771 {
2772 if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
2773 {
2774 if (!FTP_DoPassive(lpwfs))
2775 return FALSE;
2776 }
2777 else
2778 {
2779 if (!FTP_SendPort(lpwfs))
2780 return FALSE;
2781 }
2782 return TRUE;
2783 }
2784
2785
2786 /***********************************************************************
2787 * FTP_GetDataSocket (internal)
2788 *
2789 * Either accepts an incoming data socket connection from the server
2790 * or just returns the already opened socket after a PASV command
2791 * in case of passive FTP.
2792 *
2793 *
2794 * RETURNS
2795 * TRUE on success
2796 * FALSE on failure
2797 *
2798 */
2799 static BOOL FTP_GetDataSocket(LPWININETFTPSESSIONW lpwfs, LPINT nDataSocket)
2800 {
2801 struct sockaddr_in saddr;
2802 socklen_t addrlen = sizeof(struct sockaddr);
2803
2804 TRACE("\n");
2805 if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
2806 {
2807 *nDataSocket = lpwfs->pasvSocket;
2808 }
2809 else
2810 {
2811 *nDataSocket = accept(lpwfs->lstnSocket, (struct sockaddr *) &saddr, &addrlen);
2812 closesocket(lpwfs->lstnSocket);
2813 lpwfs->lstnSocket = -1;
2814 }
2815 return *nDataSocket != -1;
2816 }
2817
2818
2819 /***********************************************************************
2820 * FTP_SendData (internal)
2821 *
2822 * Send data to the server
2823 *
2824 * RETURNS
2825 * TRUE on success
2826 * FALSE on failure
2827 *
2828 */
2829 static BOOL FTP_SendData(LPWININETFTPSESSIONW lpwfs, INT nDataSocket, HANDLE hFile)
2830 {
2831 BY_HANDLE_FILE_INFORMATION fi;
2832 DWORD nBytesRead = 0;
2833 DWORD nBytesSent = 0;
2834 DWORD nTotalSent = 0;
2835 DWORD nBytesToSend, nLen;
2836 int nRC = 1;
2837 time_t s_long_time, e_long_time;
2838 LONG nSeconds;
2839 CHAR *lpszBuffer;
2840
2841 TRACE("\n");
2842 lpszBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHAR)*DATA_PACKET_SIZE);
2843
2844 /* Get the size of the file. */
2845 GetFileInformationByHandle(hFile, &fi);
2846 time(&s_long_time);
2847
2848 do
2849 {
2850 nBytesToSend = nBytesRead - nBytesSent;
2851
2852 if (nBytesToSend <= 0)
2853 {
2854 /* Read data from file. */
2855 nBytesSent = 0;
2856 if (!ReadFile(hFile, lpszBuffer, DATA_PACKET_SIZE, &nBytesRead, 0))
2857 ERR("Failed reading from file\n");
2858
2859 if (nBytesRead > 0)
2860 nBytesToSend = nBytesRead;
2861 else
2862 break;
2863 }
2864
2865 nLen = DATA_PACKET_SIZE < nBytesToSend ?
2866 DATA_PACKET_SIZE : nBytesToSend;
2867 nRC = send(nDataSocket, lpszBuffer, nLen, 0);
2868
2869 if (nRC != -1)
2870 {
2871 nBytesSent += nRC;
2872 nTotalSent += nRC;
2873 }
2874
2875 /* Do some computation to display the status. */
2876 time(&e_long_time);
2877 nSeconds = e_long_time - s_long_time;
2878 if( nSeconds / 60 > 0 )
2879 {
2880 TRACE( "%d bytes of %d bytes (%d%%) in %d min %d sec estimated remaining time %d sec\n",
2881 nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds / 60,
2882 nSeconds % 60, (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent );
2883 }
2884 else
2885 {
2886 TRACE( "%d bytes of %d bytes (%d%%) in %d sec estimated remaining time %d sec\n",
2887 nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds,
2888 (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent);
2889 }
2890 } while (nRC != -1);
2891
2892 TRACE("file transfer complete!\n");
2893
2894 HeapFree(GetProcessHeap(), 0, lpszBuffer);
2895
2896 return nTotalSent;
2897 }
2898
2899
2900 /***********************************************************************
2901 * FTP_SendRetrieve (internal)
2902 *
2903 * Send request to retrieve a file
2904 *
2905 * RETURNS
2906 * Number of bytes to be received on success
2907 * 0 on failure
2908 *
2909 */
2910 static BOOL FTP_SendRetrieve(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
2911 {
2912 INT nResCode;
2913 BOOL ret;
2914
2915 TRACE("\n");
2916 if (!(ret = FTP_InitListenSocket(lpwfs)))
2917 goto lend;
2918
2919 if (!(ret = FTP_SendType(lpwfs, dwType)))
2920 goto lend;
2921
2922 if (!(ret = FTP_SendPortOrPasv(lpwfs)))
2923 goto lend;
2924
2925 if (!(ret = FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RETR, lpszRemoteFile, 0, 0, 0)))
2926 goto lend;
2927
2928 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2929 if ((nResCode != 125) && (nResCode != 150)) {
2930 /* That means that we got an error getting the file. */
2931 FTP_SetResponseError(nResCode);
2932 ret = FALSE;
2933 }
2934
2935 lend:
2936 if (!ret && lpwfs->lstnSocket != -1)
2937 {
2938 closesocket(lpwfs->lstnSocket);
2939 lpwfs->lstnSocket = -1;
2940 }
2941
2942 return ret;
2943 }
2944
2945
2946 /***********************************************************************
2947 * FTP_RetrieveData (internal)
2948 *
2949 * Retrieve data from server
2950 *
2951 * RETURNS
2952 * TRUE on success
2953 * FALSE on failure
2954 *
2955 */
2956 static BOOL FTP_RetrieveFileData(LPWININETFTPSESSIONW lpwfs, INT nDataSocket, HANDLE hFile)
2957 {
2958 DWORD nBytesWritten;
2959 DWORD nBytesReceived = 0;
2960 INT nRC = 0;
2961 CHAR *lpszBuffer;
2962
2963 TRACE("\n");
2964
2965 lpszBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHAR)*DATA_PACKET_SIZE);
2966 if (NULL == lpszBuffer)
2967 {
2968 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2969 return FALSE;
2970 }
2971
2972 while (nRC != -1)
2973 {
2974 nRC = recv(nDataSocket, lpszBuffer, DATA_PACKET_SIZE, 0);
2975 if (nRC != -1)
2976 {
2977 /* other side closed socket. */
2978 if (nRC == 0)
2979 goto recv_end;
2980 WriteFile(hFile, lpszBuffer, nRC, &nBytesWritten, NULL);
2981 nBytesReceived += nRC;
2982 }
2983 }
2984
2985 TRACE("Data transfer complete\n");
2986
2987 recv_end:
2988 HeapFree(GetProcessHeap(), 0, lpszBuffer);
2989
2990 return (nRC != -1);
2991 }
2992
2993 /***********************************************************************
2994 * FTP_CloseConnection (internal)
2995 *
2996 * Close connections
2997 */
2998 static void FTP_CloseConnection(LPWININETHANDLEHEADER hdr)
2999 {
3000 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) hdr;
3001
3002 TRACE("\n");
3003
3004 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
3005 INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
3006
3007 if (lpwfs->download_in_progress != NULL)
3008 lpwfs->download_in_progress->session_deleted = TRUE;
3009
3010 if (lpwfs->sndSocket != -1)
3011 closesocket(lpwfs->sndSocket);
3012
3013 if (lpwfs->lstnSocket != -1)
3014 closesocket(lpwfs->lstnSocket);
3015
3016 if (lpwfs->pasvSocket != -1)
3017 closesocket(lpwfs->pasvSocket);
3018
3019 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
3020 INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
3021 }
3022
3023
3024 /***********************************************************************
3025 * FTP_CloseSessionHandle (internal)
3026 *
3027 * Deallocate session handle
3028 */
3029 static void FTP_CloseSessionHandle(LPWININETHANDLEHEADER hdr)
3030 {
3031 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) hdr;
3032
3033 TRACE("\n");
3034
3035 WININET_Release(&lpwfs->lpAppInfo->hdr);
3036
3037 HeapFree(GetProcessHeap(), 0, lpwfs->lpszPassword);
3038 HeapFree(GetProcessHeap(), 0, lpwfs->lpszUserName);
3039 HeapFree(GetProcessHeap(), 0, lpwfs);
3040 }
3041
3042
3043 /***********************************************************************
3044 * FTP_FindNextFileW (Internal)
3045 *
3046 * Continues a file search from a previous call to FindFirstFile
3047 *
3048 * RETURNS
3049 * TRUE on success
3050 * FALSE on failure
3051 *
3052 */
3053 BOOL WINAPI FTP_FindNextFileW(LPWININETFTPFINDNEXTW lpwh, LPVOID lpvFindData)
3054 {
3055 BOOL bSuccess = TRUE;
3056 LPWIN32_FIND_DATAW lpFindFileData;
3057
3058 TRACE("index(%d) size(%d)\n", lpwh->index, lpwh->size);
3059
3060 assert (lpwh->hdr.htype == WH_HFTPFINDNEXT);
3061
3062 /* Clear any error information */
3063 INTERNET_SetLastError(0);
3064
3065 lpFindFileData = (LPWIN32_FIND_DATAW) lpvFindData;
3066 ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA));
3067
3068 if (lpwh->index >= lpwh->size)
3069 {
3070 INTERNET_SetLastError(ERROR_NO_MORE_FILES);
3071 bSuccess = FALSE;
3072 goto lend;
3073 }
3074
3075 FTP_ConvertFileProp(&lpwh->lpafp[lpwh->index], lpFindFileData);
3076 lpwh->index++;
3077
3078 TRACE("\nName: %s\nSize: %d\n", debugstr_w(lpFindFileData->cFileName), lpFindFileData->nFileSizeLow);
3079
3080 lend:
3081
3082 if (lpwh->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3083 {
3084 INTERNET_ASYNC_RESULT iar;
3085
3086 iar.dwResult = (DWORD)bSuccess;
3087 iar.dwError = iar.dwError = bSuccess ? ERROR_SUCCESS :
3088 INTERNET_GetLastError();
3089
3090 INTERNET_SendCallback(&lpwh->hdr, lpwh->hdr.dwContext,
3091 INTERNET_STATUS_REQUEST_COMPLETE, &iar,
3092 sizeof(INTERNET_ASYNC_RESULT));
3093 }
3094
3095 return bSuccess;
3096 }
3097
3098
3099 /***********************************************************************
3100 * FTP_CloseFindNextHandle (internal)
3101 *
3102 * Deallocate session handle
3103 *
3104 * RETURNS
3105 * TRUE on success
3106 * FALSE on failure
3107 *
3108 */
3109 static void FTP_CloseFindNextHandle(LPWININETHANDLEHEADER hdr)
3110 {
3111 LPWININETFTPFINDNEXTW lpwfn = (LPWININETFTPFINDNEXTW) hdr;
3112 DWORD i;
3113
3114 TRACE("\n");
3115
3116 WININET_Release(&lpwfn->lpFtpSession->hdr);
3117
3118 for (i = 0; i < lpwfn->size; i++)
3119 {
3120 HeapFree(GetProcessHeap(), 0, lpwfn->lpafp[i].lpszName);
3121 }
3122
3123 HeapFree(GetProcessHeap(), 0, lpwfn->lpafp);
3124 HeapFree(GetProcessHeap(), 0, lpwfn);
3125 }
3126
3127 /***********************************************************************
3128 * FTP_CloseFileTransferHandle (internal)
3129 *
3130 * Closes the file transfer handle. This also 'cleans' the data queue of
3131 * the 'transfer complete' message (this is a bit of a hack though :-/ )
3132 *
3133 */
3134 static void FTP_CloseFileTransferHandle(LPWININETHANDLEHEADER hdr)
3135 {
3136 LPWININETFTPFILE lpwh = (LPWININETFTPFILE) hdr;
3137 LPWININETFTPSESSIONW lpwfs = lpwh->lpFtpSession;
3138 INT nResCode;
3139
3140 TRACE("\n");
3141
3142 WININET_Release(&lpwh->lpFtpSession->hdr);
3143
3144 if (!lpwh->session_deleted)
3145 lpwfs->download_in_progress = NULL;
3146
3147 if (lpwh->nDataSocket != -1)
3148 closesocket(lpwh->nDataSocket);
3149
3150 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3151 if (nResCode > 0 && nResCode != 226) WARN("server reports failed transfer\n");
3152
3153 HeapFree(GetProcessHeap(), 0, lpwh);
3154 }
3155
3156 /***********************************************************************
3157 * FTP_ReceiveFileList (internal)
3158 *
3159 * Read file list from server
3160 *
3161 * RETURNS
3162 * Handle to file list on success
3163 * NULL on failure
3164 *
3165 */
3166 static HINTERNET FTP_ReceiveFileList(LPWININETFTPSESSIONW lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
3167 LPWIN32_FIND_DATAW lpFindFileData, DWORD_PTR dwContext)
3168 {
3169 DWORD dwSize = 0;
3170 LPFILEPROPERTIESW lpafp = NULL;
3171 LPWININETFTPFINDNEXTW lpwfn = NULL;
3172 HINTERNET handle = 0;
3173
3174 TRACE("(%p,%d,%s,%p,%08lx)\n", lpwfs, nSocket, debugstr_w(lpszSearchFile), lpFindFileData, dwContext);
3175
3176 if (FTP_ParseDirectory(lpwfs, nSocket, lpszSearchFile, &lpafp, &dwSize))
3177 {
3178 if(lpFindFileData)
3179 FTP_ConvertFileProp(lpafp, lpFindFileData);
3180
3181 lpwfn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETFTPFINDNEXTW));
3182 if (lpwfn)
3183 {
3184 lpwfn->hdr.htype = WH_HFTPFINDNEXT;
3185 lpwfn->hdr.dwContext = dwContext;
3186 lpwfn->hdr.dwRefCount = 1;
3187 lpwfn->hdr.close_connection = NULL;
3188 lpwfn->hdr.destroy = FTP_CloseFindNextHandle;
3189 lpwfn->hdr.lpfnStatusCB = lpwfs->hdr.lpfnStatusCB;
3190 lpwfn->index = 1; /* Next index is 1 since we return index 0 */
3191 lpwfn->size = dwSize;
3192 lpwfn->lpafp = lpafp;
3193
3194 WININET_AddRef( &lpwfs->hdr );
3195 lpwfn->lpFtpSession = lpwfs;
3196 list_add_head( &lpwfs->hdr.children, &lpwfn->hdr.entry );
3197
3198 handle = WININET_AllocHandle( &lpwfn->hdr );
3199 }
3200 }
3201
3202 if( lpwfn )
3203 WININET_Release( &lpwfn->hdr );
3204
3205 TRACE("Matched %d files\n", dwSize);
3206 return handle;
3207 }
3208
3209
3210 /***********************************************************************
3211 * FTP_ConvertFileProp (internal)
3212 *
3213 * Converts FILEPROPERTIESW struct to WIN32_FIND_DATAA
3214 *
3215 * RETURNS
3216 * TRUE on success
3217 * FALSE on failure
3218 *
3219 */
3220 BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData)
3221 {
3222 BOOL bSuccess = FALSE;
3223
3224 ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAW));
3225
3226 if (lpafp)
3227 {
3228 /* Convert 'Unix' time to Windows time */
3229 RtlSecondsSince1970ToTime(mktime(&lpafp->tmLastModified),
3230 (LARGE_INTEGER *) &(lpFindFileData->ftLastAccessTime));
3231 lpFindFileData->ftLastWriteTime = lpFindFileData->ftLastAccessTime;
3232 lpFindFileData->ftCreationTime = lpFindFileData->ftLastAccessTime;
3233
3234 /* Not all fields are filled in */
3235 lpFindFileData->nFileSizeHigh = 0; /* We do not handle files bigger than 0xFFFFFFFF bytes yet :-) */
3236 lpFindFileData->nFileSizeLow = lpafp->nSize;
3237
3238 if (lpafp->bIsDirectory)
3239 lpFindFileData->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
3240
3241 if (lpafp->lpszName)
3242 lstrcpynW(lpFindFileData->cFileName, lpafp->lpszName, MAX_PATH);
3243
3244 bSuccess = TRUE;
3245 }
3246
3247 return bSuccess;
3248 }
3249
3250 /***********************************************************************
3251 * FTP_ParseNextFile (internal)
3252 *
3253 * Parse the next line in file listing
3254 *
3255 * RETURNS
3256 * TRUE on success
3257 * FALSE on failure
3258 */
3259 static BOOL FTP_ParseNextFile(INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW lpfp)
3260 {
3261 static const char szSpace[] = " \t";
3262 DWORD nBufLen;
3263 char *pszLine;
3264 char *pszToken;
3265 char *pszTmp;
3266 BOOL found = FALSE;
3267 int i;
3268
3269 lpfp->lpszName = NULL;
3270 do {
3271 if(!(pszLine = INTERNET_GetNextLine(nSocket, &nBufLen)))
3272 return FALSE;
3273
3274 pszToken = strtok(pszLine, szSpace);
3275 /* ls format
3276 * <Permissions> <NoLinks> <owner> <group> <size> <date> <time or year> <filename>
3277 *
3278 * For instance:
3279 * drwx--s--- 2 pcarrier ens 512 Sep 28 1995 pcarrier
3280 */
3281 if(!isdigit(pszToken[0]) && 10 == strlen(pszToken)) {
3282 if(!FTP_ParsePermission(pszToken, lpfp))
3283 lpfp->bIsDirectory = FALSE;
3284 for(i=0; i<=3; i++) {
3285 if(!(pszToken = strtok(NULL, szSpace)))
3286 break;
3287 }
3288 if(!pszToken) continue;
3289 if(lpfp->bIsDirectory) {
3290 TRACE("Is directory\n");
3291 lpfp->nSize = 0;
3292 }
3293 else {
3294 TRACE("Size: %s\n", pszToken);
3295 lpfp->nSize = atol(pszToken);
3296 }
3297
3298 lpfp->tmLastModified.tm_sec = 0;
3299 lpfp->tmLastModified.tm_min = 0;
3300 lpfp->tmLastModified.tm_hour = 0;
3301 lpfp->tmLastModified.tm_mday = 0;
3302 lpfp->tmLastModified.tm_mon = 0;
3303 lpfp->tmLastModified.tm_year = 0;
3304
3305 /* Determine month */
3306 pszToken = strtok(NULL, szSpace);
3307 if(!pszToken) continue;
3308 if(strlen(pszToken) >= 3) {
3309 pszToken[3] = 0;
3310 if((pszTmp = StrStrIA(szMonths, pszToken)))
3311 lpfp->tmLastModified.tm_mon = ((pszTmp - szMonths) / 3)+1;
3312 }
3313 /* Determine day */
3314 pszToken = strtok(NULL, szSpace);
3315 if(!pszToken) continue;
3316 lpfp->tmLastModified.tm_mday = atoi(pszToken);
3317 /* Determine time or year */
3318 pszToken = strtok(NULL, szSpace);
3319 if(!pszToken) continue;
3320 if((pszTmp = strchr(pszToken, ':'))) {
3321 struct tm* apTM;
3322 time_t aTime;
3323 *pszTmp = 0;
3324 pszTmp++;
3325 lpfp->tmLastModified.tm_min = atoi(pszTmp);
3326 lpfp->tmLastModified.tm_hour = atoi(pszToken);
3327 time(&aTime);
3328 apTM = localtime(&aTime);
3329 lpfp->tmLastModified.tm_year = apTM->tm_year;
3330 }
3331 else {
3332 lpfp->tmLastModified.tm_year = atoi(pszToken) - 1900;
3333 lpfp->tmLastModified.tm_hour = 12;
3334 }
3335 TRACE("Mod time: %02d:%02d:%02d %02d/%02d/%02d\n",
3336 lpfp->tmLastModified.tm_hour, lpfp->tmLastModified.tm_min, lpfp->tmLastModified.tm_sec,
3337 (lpfp->tmLastModified.tm_year >= 100) ? lpfp->tmLastModified.tm_year - 100 : lpfp->tmLastModified.tm_year,
3338 lpfp->tmLastModified.tm_mon, lpfp->tmLastModified.tm_mday);
3339
3340 pszToken = strtok(NULL, szSpace);
3341 if(!pszToken) continue;
3342 lpfp->lpszName = WININET_strdup_AtoW(pszToken);
3343 TRACE("File: %s\n", debugstr_w(lpfp->lpszName));
3344 }
3345 /* NT way of parsing ... :
3346
3347 07-13-03 08:55PM <DIR> sakpatch
3348 05-09-03 06:02PM 12656686 2003-04-21bgm_cmd_e.rgz
3349 */
3350 else if(isdigit(pszToken[0]) && 8 == strlen(pszToken)) {
3351 lpfp->permissions = 0xFFFF; /* No idea, put full permission :-) */
3352
3353 sscanf(pszToken, "%d-%d-%d",
3354 &lpfp->tmLastModified.tm_mon,
3355 &lpfp->tmLastModified.tm_mday,
3356 &lpfp->tmLastModified.tm_year);
3357
3358 /* Hacky and bad Y2K protection :-) */
3359 if (lpfp->tmLastModified.tm_year < 70)
3360 lpfp->tmLastModified.tm_year += 100;
3361
3362 pszToken = strtok(NULL, szSpace);
3363 if(!pszToken) continue;
3364 sscanf(pszToken, "%d:%d",
3365 &lpfp->tmLastModified.tm_hour,
3366 &lpfp->tmLastModified.tm_min);
3367 if((pszToken[5] == 'P') && (pszToken[6] == 'M')) {
3368 lpfp->tmLastModified.tm_hour += 12;
3369 }
3370 lpfp->tmLastModified.tm_sec = 0;
3371
3372 TRACE("Mod time: %02d:%02d:%02d %02d/%02d/%02d\n",
3373 lpfp->tmLastModified.tm_hour, lpfp->tmLastModified.tm_min, lpfp->tmLastModified.tm_sec,
3374 (lpfp->tmLastModified.tm_year >= 100) ? lpfp->tmLastModified.tm_year - 100 : lpfp->tmLastModified.tm_year,
3375 lpfp->tmLastModified.tm_mon, lpfp->tmLastModified.tm_mday);
3376
3377 pszToken = strtok(NULL, szSpace);
3378 if(!pszToken) continue;
3379 if(!strcasecmp(pszToken, "<DIR>")) {
3380 lpfp->bIsDirectory = TRUE;
3381 lpfp->nSize = 0;
3382 TRACE("Is directory\n");
3383 }
3384 else {
3385 lpfp->bIsDirectory = FALSE;
3386 lpfp->nSize = atol(pszToken);
3387 TRACE("Size: %d\n", lpfp->nSize);
3388 }
3389
3390 pszToken = strtok(NULL, szSpace);
3391 if(!pszToken) continue;
3392 lpfp->lpszName = WININET_strdup_AtoW(pszToken);
3393 TRACE("Name: %s\n", debugstr_w(lpfp->lpszName));
3394 }
3395 /* EPLF format - http://cr.yp.to/ftp/list/eplf.html */
3396 else if(pszToken[0] == '+') {
3397 FIXME("EPLF Format not implemented\n");
3398 }
3399
3400 if(lpfp->lpszName) {
3401 if((lpszSearchFile == NULL) ||
3402 (PathMatchSpecW(lpfp->lpszName, lpszSearchFile))) {
3403 found = TRUE;
3404 TRACE("Matched: %s\n", debugstr_w(lpfp->lpszName));
3405 }
3406 else {
3407 HeapFree(GetProcessHeap(), 0, lpfp->lpszName);
3408 lpfp->lpszName = NULL;
3409 }
3410 }
3411 } while(!found);
3412 return TRUE;
3413 }
3414
3415 /***********************************************************************
3416 * FTP_ParseDirectory (internal)
3417 *
3418 * Parse string of directory information
3419 *
3420 * RETURNS
3421 * TRUE on success
3422 * FALSE on failure
3423 */
3424 static BOOL FTP_ParseDirectory(LPWININETFTPSESSIONW lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
3425 LPFILEPROPERTIESW *lpafp, LPDWORD dwfp)
3426 {
3427 BOOL bSuccess = TRUE;
3428 INT sizeFilePropArray = 500;/*20; */
3429 INT indexFilePropArray = -1;
3430
3431 TRACE("\n");
3432
3433 /* Allocate intial file properties array */
3434 *lpafp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FILEPROPERTIESW)*(sizeFilePropArray));
3435 if (!*lpafp)
3436 return FALSE;
3437
3438 do {
3439 if (indexFilePropArray+1 >= sizeFilePropArray)
3440 {
3441 LPFILEPROPERTIESW tmpafp;
3442
3443 sizeFilePropArray *= 2;
3444 tmpafp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *lpafp,
3445 sizeof(FILEPROPERTIESW)*sizeFilePropArray);
3446 if (NULL == tmpafp)
3447 {
3448 bSuccess = FALSE;
3449 break;
3450 }
3451
3452 *lpafp = tmpafp;
3453 }
3454 indexFilePropArray++;
3455 } while (FTP_ParseNextFile(nSocket, lpszSearchFile, &(*lpafp)[indexFilePropArray]));
3456
3457 if (bSuccess && indexFilePropArray)
3458 {
3459 if (indexFilePropArray < sizeFilePropArray - 1)
3460 {
3461 LPFILEPROPERTIESW tmpafp;
3462
3463 tmpafp = HeapReAlloc(GetProcessHeap(), 0, *lpafp,
3464 sizeof(FILEPROPERTIESW)*indexFilePropArray);
3465 if (NULL != tmpafp)
3466 *lpafp = tmpafp;
3467 }
3468 *dwfp = indexFilePropArray;
3469 }
3470 else
3471 {
3472 HeapFree(GetProcessHeap(), 0, *lpafp);
3473 INTERNET_SetLastError(ERROR_NO_MORE_FILES);
3474 bSuccess = FALSE;
3475 }
3476
3477 return bSuccess;
3478 }
3479
3480
3481 /***********************************************************************
3482 * FTP_ParsePermission (internal)
3483 *
3484 * Parse permission string of directory information
3485 *
3486 * RETURNS
3487 * TRUE on success
3488 * FALSE on failure
3489 *
3490 */
3491 static BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp)
3492 {
3493 BOOL bSuccess = TRUE;
3494 unsigned short nPermission = 0;
3495 INT nPos = 1;
3496 INT nLast = 9;
3497
3498 TRACE("\n");
3499 if ((*lpszPermission != 'd') && (*lpszPermission != '-') && (*lpszPermission != 'l'))
3500 {
3501 bSuccess = FALSE;
3502 return bSuccess;
3503 }
3504
3505 lpfp->bIsDirectory = (*lpszPermission == 'd');
3506 do
3507 {
3508 switch (nPos)
3509 {
3510 case 1:
3511 nPermission |= (*(lpszPermission+1) == 'r' ? 1 : 0) << 8;
3512 break;
3513 case 2:
3514 nPermission |= (*(lpszPermission+2) == 'w' ? 1 : 0) << 7;
3515 break;
3516 case 3:
3517 nPermission |= (*(lpszPermission+3) == 'x' ? 1 : 0) << 6;
3518 break;
3519 case 4:
3520 nPermission |= (*(lpszPermission+4) == 'r' ? 1 : 0) << 5;
3521 break;
3522 case 5:
3523 nPermission |= (*(lpszPermission+5) == 'w' ? 1 : 0) << 4;
3524 break;
3525 case 6:
3526 nPermission |= (*(lpszPermission+6) == 'x' ? 1 : 0) << 3;
3527 break;
3528 case 7:
3529 nPermission |= (*(lpszPermission+7) == 'r' ? 1 : 0) << 2;
3530 break;
3531 case 8:
3532 nPermission |= (*(lpszPermission+8) == 'w' ? 1 : 0) << 1;
3533 break;
3534 case 9:
3535 nPermission |= (*(lpszPermission+9) == 'x' ? 1 : 0);
3536 break;
3537 }
3538 nPos++;
3539 }while (nPos <= nLast);
3540
3541 lpfp->permissions = nPermission;
3542 return bSuccess;
3543 }
3544
3545
3546 /***********************************************************************
3547 * FTP_SetResponseError (internal)
3548 *
3549 * Set the appropriate error code for a given response from the server
3550 *
3551 * RETURNS
3552 *
3553 */
3554 static DWORD FTP_SetResponseError(DWORD dwResponse)
3555 {
3556 DWORD dwCode = 0;
3557
3558 switch(dwResponse)
3559 {
3560 case 425: /* Cannot open data connection. */
3561 dwCode = ERROR_INTERNET_CANNOT_CONNECT;
3562 break;
3563
3564 case 426: /* Connection closed, transer aborted. */
3565 dwCode = ERROR_INTERNET_CONNECTION_ABORTED;
3566 break;
3567
3568 case 530: /* Not logged in. Login incorrect. */
3569 dwCode = ERROR_INTERNET_LOGIN_FAILURE;
3570 break;
3571
3572 case 421: /* Service not available - Server may be shutting down. */
3573 case 450: /* File action not taken. File may be busy. */
3574 case 451: /* Action aborted. Server error. */
3575 case 452: /* Action not taken. Insufficient storage space on server. */
3576 case 500: /* Syntax error. Command unrecognized. */
3577 case 501: /* Syntax error. Error in parameters or arguments. */
3578 case 502: /* Command not implemented. */
3579 case 503: /* Bad sequence of commands. */
3580 case 504: /* Command not implemented for that parameter. */
3581 case 532: /* Need account for storing files */
3582 case 550: /* File action not taken. File not found or no access. */
3583 case 551: /* Requested action aborted. Page type unknown */
3584 case 552: /* Action aborted. Exceeded storage allocation */
3585 case 553: /* Action not taken. File name not allowed. */
3586
3587 default:
3588 dwCode = ERROR_INTERNET_EXTENDED_ERROR;
3589 break;
3590 }
3591
3592 INTERNET_SetLastError(dwCode);
3593 return dwCode;
3594 }
useful hacks and other patches not (yet) suitable for mainline