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