?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wininet: Return NULL handle if no connection is established.
[wine.git] / dlls / wininet / ftp.c
blob03540e6b6ffce999ba4a50b8a59ccfc04e8da934
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_FtpRenameFileW (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 handle = NULL;
1810 lpwfs = NULL;
1811 }
1812
1813 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1814 {
1815 INTERNET_ASYNC_RESULT iar;
1816
1817 iar.dwResult = (DWORD)lpwfs;
1818 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1819 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1820 &iar, sizeof(INTERNET_ASYNC_RESULT));
1821 }
1822
1823 return handle;
1824 }
1825
1826
1827 /***********************************************************************
1828 * FTP_ConnectToHost (internal)
1829 *
1830 * Connect to a ftp server
1831 *
1832 * RETURNS
1833 * TRUE on success
1834 * NULL on failure
1835 *
1836 */
1837 static BOOL FTP_ConnectToHost(LPWININETFTPSESSIONW lpwfs)
1838 {
1839 INT nResCode;
1840 BOOL bSuccess = FALSE;
1841
1842 TRACE("\n");
1843 FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1844
1845 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_USER, lpwfs->lpszUserName, 0, 0, 0))
1846 goto lend;
1847
1848 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1849 if (nResCode)
1850 {
1851 /* Login successful... */
1852 if (nResCode == 230)
1853 bSuccess = TRUE;
1854 /* User name okay, need password... */
1855 else if (nResCode == 331)
1856 bSuccess = FTP_SendPassword(lpwfs);
1857 /* Need account for login... */
1858 else if (nResCode == 332)
1859 bSuccess = FTP_SendAccount(lpwfs);
1860 else
1861 FTP_SetResponseError(nResCode);
1862 }
1863
1864 TRACE("Returning %d\n", bSuccess);
1865 lend:
1866 return bSuccess;
1867 }
1868
1869
1870 /***********************************************************************
1871 * FTP_SendCommandA (internal)
1872 *
1873 * Send command to server
1874 *
1875 * RETURNS
1876 * TRUE on success
1877 * NULL on failure
1878 *
1879 */
1880 static BOOL FTP_SendCommandA(INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam,
1881 INTERNET_STATUS_CALLBACK lpfnStatusCB, LPWININETHANDLEHEADER hdr, DWORD dwContext)
1882 {
1883 DWORD len;
1884 CHAR *buf;
1885 DWORD nBytesSent = 0;
1886 int nRC = 0;
1887 DWORD dwParamLen;
1888
1889 TRACE("%d: (%s) %d\n", ftpCmd, lpszParam, nSocket);
1890
1891 if (lpfnStatusCB)
1892 {
1893 HINTERNET hHandle = WININET_FindHandle( hdr );
1894 if( hHandle )
1895 {
1896 lpfnStatusCB(hHandle, dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
1897 WININET_Release( hdr );
1898 }
1899 }
1900
1901 dwParamLen = lpszParam?strlen(lpszParam)+1:0;
1902 len = dwParamLen + strlen(szFtpCommands[ftpCmd]) + strlen(szCRLF);
1903 if (NULL == (buf = HeapAlloc(GetProcessHeap(), 0, len+1)))
1904 {
1905 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1906 return FALSE;
1907 }
1908 sprintf(buf, "%s%s%s%s", szFtpCommands[ftpCmd], dwParamLen ? " " : "",
1909 dwParamLen ? lpszParam : "", szCRLF);
1910
1911 TRACE("Sending (%s) len(%ld)\n", buf, len);
1912 while((nBytesSent < len) && (nRC != -1))
1913 {
1914 nRC = send(nSocket, buf+nBytesSent, len - nBytesSent, 0);
1915 nBytesSent += nRC;
1916 }
1917
1918 HeapFree(GetProcessHeap(), 0, (LPVOID)buf);
1919
1920 if (lpfnStatusCB)
1921 {
1922 HINTERNET hHandle = WININET_FindHandle( hdr );
1923 if( hHandle )
1924 {
1925 lpfnStatusCB(hHandle, dwContext, INTERNET_STATUS_REQUEST_SENT,
1926 &nBytesSent, sizeof(DWORD));
1927 WININET_Release( hdr );
1928 }
1929 }
1930
1931 TRACE("Sent %ld bytes\n", nBytesSent);
1932 return (nRC != -1);
1933 }
1934
1935 /***********************************************************************
1936 * FTP_SendCommand (internal)
1937 *
1938 * Send command to server
1939 *
1940 * RETURNS
1941 * TRUE on success
1942 * NULL on failure
1943 *
1944 */
1945 static BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam,
1946 INTERNET_STATUS_CALLBACK lpfnStatusCB, LPWININETHANDLEHEADER hdr, DWORD dwContext)
1947 {
1948 BOOL ret;
1949 LPSTR lpszParamA = lpszParam?WININET_strdup_WtoA(lpszParam):NULL;
1950 ret = FTP_SendCommandA(nSocket, ftpCmd, lpszParamA, lpfnStatusCB, hdr, dwContext);
1951 HeapFree(GetProcessHeap(), 0, lpszParamA);
1952 return ret;
1953 }
1954
1955 /***********************************************************************
1956 * FTP_ReceiveResponse (internal)
1957 *
1958 * Receive response from server
1959 *
1960 * RETURNS
1961 * Reply code on success
1962 * 0 on failure
1963 *
1964 */
1965 INT FTP_ReceiveResponse(LPWININETFTPSESSIONW lpwfs, DWORD dwContext)
1966 {
1967 LPSTR lpszResponse = INTERNET_GetResponseBuffer();
1968 DWORD nRecv;
1969 INT rc = 0;
1970 char firstprefix[5];
1971 BOOL multiline = FALSE;
1972 LPWININETAPPINFOW hIC = NULL;
1973
1974 TRACE("socket(%d)\n", lpwfs->sndSocket);
1975
1976 hIC = (LPWININETAPPINFOW) lpwfs->hdr.lpwhparent;
1977 SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
1978
1979 while(1)
1980 {
1981 if (!INTERNET_GetNextLine(lpwfs->sndSocket, &nRecv))
1982 goto lerror;
1983
1984 if (nRecv >= 3)
1985 {
1986 if(!multiline)
1987 {
1988 if(lpszResponse[3] != '-')
1989 break;
1990 else
1991 { /* Start of multiline repsonse. Loop until we get "nnn " */
1992 multiline = TRUE;
1993 memcpy(firstprefix, lpszResponse, 3);
1994 firstprefix[3] = ' ';
1995 firstprefix[4] = '\0';
1996 }
1997 }
1998 else
1999 {
2000 if(!memcmp(firstprefix, lpszResponse, 4))
2001 break;
2002 }
2003 }
2004 }
2005
2006 if (nRecv >= 3)
2007 {
2008 rc = atoi(lpszResponse);
2009
2010 SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2011 &nRecv, sizeof(DWORD));
2012 }
2013
2014 lerror:
2015 TRACE("return %d\n", rc);
2016 return rc;
2017 }
2018
2019
2020 /***********************************************************************
2021 * FTP_SendPassword (internal)
2022 *
2023 * Send password to ftp server
2024 *
2025 * RETURNS
2026 * TRUE on success
2027 * NULL on failure
2028 *
2029 */
2030 static BOOL FTP_SendPassword(LPWININETFTPSESSIONW lpwfs)
2031 {
2032 INT nResCode;
2033 BOOL bSuccess = FALSE;
2034
2035 TRACE("\n");
2036 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASS, lpwfs->lpszPassword, 0, 0, 0))
2037 goto lend;
2038
2039 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2040 if (nResCode)
2041 {
2042 TRACE("Received reply code %d\n", nResCode);
2043 /* Login successful... */
2044 if (nResCode == 230)
2045 bSuccess = TRUE;
2046 /* Command not implemented, superfluous at the server site... */
2047 /* Need account for login... */
2048 else if (nResCode == 332)
2049 bSuccess = FTP_SendAccount(lpwfs);
2050 else
2051 FTP_SetResponseError(nResCode);
2052 }
2053
2054 lend:
2055 TRACE("Returning %d\n", bSuccess);
2056 return bSuccess;
2057 }
2058
2059
2060 /***********************************************************************
2061 * FTP_SendAccount (internal)
2062 *
2063 *
2064 *
2065 * RETURNS
2066 * TRUE on success
2067 * FALSE on failure
2068 *
2069 */
2070 static BOOL FTP_SendAccount(LPWININETFTPSESSIONW lpwfs)
2071 {
2072 INT nResCode;
2073 BOOL bSuccess = FALSE;
2074
2075 TRACE("\n");
2076 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_ACCT, szNoAccount, 0, 0, 0))
2077 goto lend;
2078
2079 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2080 if (nResCode)
2081 bSuccess = TRUE;
2082 else
2083 FTP_SetResponseError(nResCode);
2084
2085 lend:
2086 return bSuccess;
2087 }
2088
2089
2090 /***********************************************************************
2091 * FTP_SendStore (internal)
2092 *
2093 * Send request to upload file to ftp server
2094 *
2095 * RETURNS
2096 * TRUE on success
2097 * FALSE on failure
2098 *
2099 */
2100 static BOOL FTP_SendStore(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
2101 {
2102 INT nResCode;
2103 BOOL bSuccess = FALSE;
2104
2105 TRACE("\n");
2106 if (!FTP_InitListenSocket(lpwfs))
2107 goto lend;
2108
2109 if (!FTP_SendType(lpwfs, dwType))
2110 goto lend;
2111
2112 if (!FTP_SendPortOrPasv(lpwfs))
2113 goto lend;
2114
2115 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_STOR, lpszRemoteFile, 0, 0, 0))
2116 goto lend;
2117 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2118 if (nResCode)
2119 {
2120 if (nResCode == 150 || nResCode == 125)
2121 bSuccess = TRUE;
2122 else
2123 FTP_SetResponseError(nResCode);
2124 }
2125
2126 lend:
2127 if (!bSuccess && lpwfs->lstnSocket != -1)
2128 {
2129 closesocket(lpwfs->lstnSocket);
2130 lpwfs->lstnSocket = -1;
2131 }
2132
2133 return bSuccess;
2134 }
2135
2136
2137 /***********************************************************************
2138 * FTP_InitListenSocket (internal)
2139 *
2140 * Create a socket to listen for server response
2141 *
2142 * RETURNS
2143 * TRUE on success
2144 * FALSE on failure
2145 *
2146 */
2147 static BOOL FTP_InitListenSocket(LPWININETFTPSESSIONW lpwfs)
2148 {
2149 BOOL bSuccess = FALSE;
2150 size_t namelen = sizeof(struct sockaddr_in);
2151
2152 TRACE("\n");
2153
2154 lpwfs->lstnSocket = socket(PF_INET, SOCK_STREAM, 0);
2155 if (lpwfs->lstnSocket == -1)
2156 {
2157 TRACE("Unable to create listening socket\n");
2158 goto lend;
2159 }
2160
2161 /* We obtain our ip addr from the name of the command channel socket */
2162 lpwfs->lstnSocketAddress = lpwfs->socketAddress;
2163
2164 /* and get the system to assign us a port */
2165 lpwfs->lstnSocketAddress.sin_port = htons((u_short) 0);
2166
2167 if (bind(lpwfs->lstnSocket,(struct sockaddr *) &lpwfs->lstnSocketAddress, sizeof(struct sockaddr_in)) == -1)
2168 {
2169 TRACE("Unable to bind socket\n");
2170 goto lend;
2171 }
2172
2173 if (listen(lpwfs->lstnSocket, MAX_BACKLOG) == -1)
2174 {
2175 TRACE("listen failed\n");
2176 goto lend;
2177 }
2178
2179 if (getsockname(lpwfs->lstnSocket, (struct sockaddr *) &lpwfs->lstnSocketAddress, &namelen) != -1)
2180 bSuccess = TRUE;
2181
2182 lend:
2183 if (!bSuccess && lpwfs->lstnSocket == -1)
2184 {
2185 closesocket(lpwfs->lstnSocket);
2186 lpwfs->lstnSocket = -1;
2187 }
2188
2189 return bSuccess;
2190 }
2191
2192
2193 /***********************************************************************
2194 * FTP_SendType (internal)
2195 *
2196 * Tell server type of data being transferred
2197 *
2198 * RETURNS
2199 * TRUE on success
2200 * FALSE on failure
2201 *
2202 * W98SE doesn't cache the type that's currently set
2203 * (i.e. it sends it always),
2204 * so we probably don't want to do that either.
2205 */
2206 static BOOL FTP_SendType(LPWININETFTPSESSIONW lpwfs, DWORD dwType)
2207 {
2208 INT nResCode;
2209 WCHAR type[] = { 'I','\0' };
2210 BOOL bSuccess = FALSE;
2211
2212 TRACE("\n");
2213 if (dwType & INTERNET_FLAG_TRANSFER_ASCII)
2214 type[0] = 'A';
2215
2216 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_TYPE, type, 0, 0, 0))
2217 goto lend;
2218
2219 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext)/100;
2220 if (nResCode)
2221 {
2222 if (nResCode == 2)
2223 bSuccess = TRUE;
2224 else
2225 FTP_SetResponseError(nResCode);
2226 }
2227
2228 lend:
2229 return bSuccess;
2230 }
2231
2232 /***********************************************************************
2233 * FTP_GetFileSize (internal)
2234 *
2235 * Retrieves from the server the size of the given file
2236 *
2237 * RETURNS
2238 * TRUE on success
2239 * FALSE on failure
2240 *
2241 */
2242 static BOOL FTP_GetFileSize(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD *dwSize)
2243 {
2244 INT nResCode;
2245 BOOL bSuccess = FALSE;
2246
2247 TRACE("\n");
2248
2249 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_SIZE, lpszRemoteFile, 0, 0, 0))
2250 goto lend;
2251
2252 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2253 if (nResCode)
2254 {
2255 if (nResCode == 213) {
2256 /* Now parses the output to get the actual file size */
2257 int i;
2258 LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
2259
2260 for (i = 0; (lpszResponseBuffer[i] != ' ') && (lpszResponseBuffer[i] != '\0'); i++) ;
2261 if (lpszResponseBuffer[i] == '\0') return FALSE;
2262 *dwSize = atol(&(lpszResponseBuffer[i + 1]));
2263
2264 bSuccess = TRUE;
2265 } else {
2266 FTP_SetResponseError(nResCode);
2267 }
2268 }
2269
2270 lend:
2271 return bSuccess;
2272 }
2273
2274
2275 /***********************************************************************
2276 * FTP_SendPort (internal)
2277 *
2278 * Tell server which port to use
2279 *
2280 * RETURNS
2281 * TRUE on success
2282 * FALSE on failure
2283 *
2284 */
2285 static BOOL FTP_SendPort(LPWININETFTPSESSIONW lpwfs)
2286 {
2287 static const WCHAR szIPFormat[] = {'%','d',',','%','d',',','%','d',',','%','d',',','%','d',',','%','d','\0'};
2288 INT nResCode;
2289 WCHAR szIPAddress[64];
2290 BOOL bSuccess = FALSE;
2291 TRACE("\n");
2292
2293 sprintfW(szIPAddress, szIPFormat,
2294 lpwfs->lstnSocketAddress.sin_addr.s_addr&0x000000FF,
2295 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x0000FF00)>>8,
2296 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x00FF0000)>>16,
2297 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0xFF000000)>>24,
2298 lpwfs->lstnSocketAddress.sin_port & 0xFF,
2299 (lpwfs->lstnSocketAddress.sin_port & 0xFF00)>>8);
2300
2301 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PORT, szIPAddress, 0, 0, 0))
2302 goto lend;
2303
2304 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2305 if (nResCode)
2306 {
2307 if (nResCode == 200)
2308 bSuccess = TRUE;
2309 else
2310 FTP_SetResponseError(nResCode);
2311 }
2312
2313 lend:
2314 return bSuccess;
2315 }
2316
2317
2318 /***********************************************************************
2319 * FTP_DoPassive (internal)
2320 *
2321 * Tell server that we want to do passive transfers
2322 * and connect data socket
2323 *
2324 * RETURNS
2325 * TRUE on success
2326 * FALSE on failure
2327 *
2328 */
2329 static BOOL FTP_DoPassive(LPWININETFTPSESSIONW lpwfs)
2330 {
2331 INT nResCode;
2332 BOOL bSuccess = FALSE;
2333
2334 TRACE("\n");
2335 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASV, NULL, 0, 0, 0))
2336 goto lend;
2337
2338 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2339 if (nResCode)
2340 {
2341 if (nResCode == 227)
2342 {
2343 LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
2344 LPSTR p;
2345 int f[6];
2346 int i;
2347 char *pAddr, *pPort;
2348 INT nsocket = -1;
2349 struct sockaddr_in dataSocketAddress;
2350
2351 p = lpszResponseBuffer+4; /* skip status code */
2352
2353 /* do a very strict check; we can improve that later. */
2354
2355 if (strncmp(p, "Entering Passive Mode", 21))
2356 {
2357 ERR("unknown response '%.*s', aborting\n", 21, p);
2358 goto lend;
2359 }
2360 p += 21; /* skip string */
2361 if ((*p++ != ' ') || (*p++ != '('))
2362 {
2363 ERR("unknown response format, aborting\n");
2364 goto lend;
2365 }
2366
2367 if (sscanf(p, "%d,%d,%d,%d,%d,%d", &f[0], &f[1], &f[2], &f[3],
2368 &f[4], &f[5]) != 6)
2369 {
2370 ERR("unknown response address format '%s', aborting\n", p);
2371 goto lend;
2372 }
2373 for (i=0; i < 6; i++)
2374 f[i] = f[i] & 0xff;
2375
2376 dataSocketAddress = lpwfs->socketAddress;
2377 pAddr = (char *)&(dataSocketAddress.sin_addr.s_addr);
2378 pPort = (char *)&(dataSocketAddress.sin_port);
2379 pAddr[0] = f[0];
2380 pAddr[1] = f[1];
2381 pAddr[2] = f[2];
2382 pAddr[3] = f[3];
2383 pPort[0] = f[4];
2384 pPort[1] = f[5];
2385
2386 nsocket = socket(AF_INET,SOCK_STREAM,0);
2387 if (nsocket == -1)
2388 goto lend;
2389
2390 if (connect(nsocket, (struct sockaddr *)&dataSocketAddress, sizeof(dataSocketAddress)))
2391 {
2392 ERR("can't connect passive FTP data port.\n");
2393 goto lend;
2394 }
2395 lpwfs->pasvSocket = nsocket;
2396 bSuccess = TRUE;
2397 }
2398 else
2399 FTP_SetResponseError(nResCode);
2400 }
2401
2402 lend:
2403 return bSuccess;
2404 }
2405
2406
2407 static BOOL FTP_SendPortOrPasv(LPWININETFTPSESSIONW lpwfs)
2408 {
2409 if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
2410 {
2411 if (!FTP_DoPassive(lpwfs))
2412 return FALSE;
2413 }
2414 else
2415 {
2416 if (!FTP_SendPort(lpwfs))
2417 return FALSE;
2418 }
2419 return TRUE;
2420 }
2421
2422
2423 /***********************************************************************
2424 * FTP_GetDataSocket (internal)
2425 *
2426 * Either accepts an incoming data socket connection from the server
2427 * or just returns the already opened socket after a PASV command
2428 * in case of passive FTP.
2429 *
2430 *
2431 * RETURNS
2432 * TRUE on success
2433 * FALSE on failure
2434 *
2435 */
2436 static BOOL FTP_GetDataSocket(LPWININETFTPSESSIONW lpwfs, LPINT nDataSocket)
2437 {
2438 struct sockaddr_in saddr;
2439 size_t addrlen = sizeof(struct sockaddr);
2440
2441 TRACE("\n");
2442 if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
2443 {
2444 *nDataSocket = lpwfs->pasvSocket;
2445 }
2446 else
2447 {
2448 *nDataSocket = accept(lpwfs->lstnSocket, (struct sockaddr *) &saddr, &addrlen);
2449 closesocket(lpwfs->lstnSocket);
2450 lpwfs->lstnSocket = -1;
2451 }
2452 return *nDataSocket != -1;
2453 }
2454
2455
2456 /***********************************************************************
2457 * FTP_SendData (internal)
2458 *
2459 * Send data to the server
2460 *
2461 * RETURNS
2462 * TRUE on success
2463 * FALSE on failure
2464 *
2465 */
2466 static BOOL FTP_SendData(LPWININETFTPSESSIONW lpwfs, INT nDataSocket, HANDLE hFile)
2467 {
2468 BY_HANDLE_FILE_INFORMATION fi;
2469 DWORD nBytesRead = 0;
2470 DWORD nBytesSent = 0;
2471 DWORD nTotalSent = 0;
2472 DWORD nBytesToSend, nLen;
2473 int nRC = 1;
2474 time_t s_long_time, e_long_time;
2475 LONG nSeconds;
2476 CHAR *lpszBuffer;
2477
2478 TRACE("\n");
2479 lpszBuffer = HeapAlloc(GetProcessHeap(), 0, sizeof(CHAR)*DATA_PACKET_SIZE);
2480 memset(lpszBuffer, 0, sizeof(CHAR)*DATA_PACKET_SIZE);
2481
2482 /* Get the size of the file. */
2483 GetFileInformationByHandle(hFile, &fi);
2484 time(&s_long_time);
2485
2486 do
2487 {
2488 nBytesToSend = nBytesRead - nBytesSent;
2489
2490 if (nBytesToSend <= 0)
2491 {
2492 /* Read data from file. */
2493 nBytesSent = 0;
2494 if (!ReadFile(hFile, lpszBuffer, DATA_PACKET_SIZE, &nBytesRead, 0))
2495 ERR("Failed reading from file\n");
2496
2497 if (nBytesRead > 0)
2498 nBytesToSend = nBytesRead;
2499 else
2500 break;
2501 }
2502
2503 nLen = DATA_PACKET_SIZE < nBytesToSend ?
2504 DATA_PACKET_SIZE : nBytesToSend;
2505 nRC = send(nDataSocket, lpszBuffer, nLen, 0);
2506
2507 if (nRC != -1)
2508 {
2509 nBytesSent += nRC;
2510 nTotalSent += nRC;
2511 }
2512
2513 /* Do some computation to display the status. */
2514 time(&e_long_time);
2515 nSeconds = e_long_time - s_long_time;
2516 if( nSeconds / 60 > 0 )
2517 {
2518 TRACE( "%ld bytes of %ld bytes (%ld%%) in %ld min %ld sec estimated remaining time %ld sec\n",
2519 nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds / 60,
2520 nSeconds % 60, (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent );
2521 }
2522 else
2523 {
2524 TRACE( "%ld bytes of %ld bytes (%ld%%) in %ld sec estimated remaining time %ld sec\n",
2525 nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds,
2526 (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent);
2527 }
2528 } while (nRC != -1);
2529
2530 TRACE("file transfer complete!\n");
2531
2532 HeapFree(GetProcessHeap(), 0, lpszBuffer);
2533
2534 return nTotalSent;
2535 }
2536
2537
2538 /***********************************************************************
2539 * FTP_SendRetrieve (internal)
2540 *
2541 * Send request to retrieve a file
2542 *
2543 * RETURNS
2544 * Number of bytes to be received on success
2545 * 0 on failure
2546 *
2547 */
2548 static DWORD FTP_SendRetrieve(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
2549 {
2550 INT nResCode;
2551 DWORD nResult = 0;
2552
2553 TRACE("\n");
2554 if (!FTP_InitListenSocket(lpwfs))
2555 goto lend;
2556
2557 if (!FTP_SendType(lpwfs, dwType))
2558 goto lend;
2559
2560 if (!FTP_SendPortOrPasv(lpwfs))
2561 goto lend;
2562
2563 if (!FTP_GetFileSize(lpwfs, lpszRemoteFile, &nResult))
2564 goto lend;
2565
2566 TRACE("Waiting to receive %ld bytes\n", nResult);
2567
2568 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RETR, lpszRemoteFile, 0, 0, 0))
2569 goto lend;
2570
2571 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2572 if ((nResCode != 125) && (nResCode != 150)) {
2573 /* That means that we got an error getting the file. */
2574 nResult = 0;
2575 }
2576
2577 lend:
2578 if (0 == nResult && lpwfs->lstnSocket != -1)
2579 {
2580 closesocket(lpwfs->lstnSocket);
2581 lpwfs->lstnSocket = -1;
2582 }
2583
2584 return nResult;
2585 }
2586
2587
2588 /***********************************************************************
2589 * FTP_RetrieveData (internal)
2590 *
2591 * Retrieve data from server
2592 *
2593 * RETURNS
2594 * TRUE on success
2595 * FALSE on failure
2596 *
2597 */
2598 static BOOL FTP_RetrieveFileData(LPWININETFTPSESSIONW lpwfs, INT nDataSocket, DWORD nBytes, HANDLE hFile)
2599 {
2600 DWORD nBytesWritten;
2601 DWORD nBytesReceived = 0;
2602 INT nRC = 0;
2603 CHAR *lpszBuffer;
2604
2605 TRACE("\n");
2606
2607 if (INVALID_HANDLE_VALUE == hFile)
2608 return FALSE;
2609
2610 lpszBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHAR)*DATA_PACKET_SIZE);
2611 if (NULL == lpszBuffer)
2612 {
2613 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2614 return FALSE;
2615 }
2616
2617 while (nBytesReceived < nBytes && nRC != -1)
2618 {
2619 nRC = recv(nDataSocket, lpszBuffer, DATA_PACKET_SIZE, 0);
2620 if (nRC != -1)
2621 {
2622 /* other side closed socket. */
2623 if (nRC == 0)
2624 goto recv_end;
2625 WriteFile(hFile, lpszBuffer, nRC, &nBytesWritten, NULL);
2626 nBytesReceived += nRC;
2627 }
2628
2629 TRACE("%ld bytes of %ld (%ld%%)\r", nBytesReceived, nBytes,
2630 nBytesReceived * 100 / nBytes);
2631 }
2632
2633 TRACE("Data transfer complete\n");
2634 HeapFree(GetProcessHeap(), 0, lpszBuffer);
2635
2636 recv_end:
2637 return (nRC != -1);
2638 }
2639
2640
2641 /***********************************************************************
2642 * FTP_CloseSessionHandle (internal)
2643 *
2644 * Deallocate session handle
2645 *
2646 * RETURNS
2647 * TRUE on success
2648 * FALSE on failure
2649 *
2650 */
2651 static void FTP_CloseSessionHandle(LPWININETHANDLEHEADER hdr)
2652 {
2653 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) hdr;
2654
2655 TRACE("\n");
2656
2657 if (lpwfs->download_in_progress != NULL)
2658 lpwfs->download_in_progress->session_deleted = TRUE;
2659
2660 if (lpwfs->sndSocket != -1)
2661 closesocket(lpwfs->sndSocket);
2662
2663 if (lpwfs->lstnSocket != -1)
2664 closesocket(lpwfs->lstnSocket);
2665
2666 HeapFree(GetProcessHeap(), 0, lpwfs->lpszPassword);
2667 HeapFree(GetProcessHeap(), 0, lpwfs->lpszUserName);
2668 HeapFree(GetProcessHeap(), 0, lpwfs);
2669 }
2670
2671
2672 /***********************************************************************
2673 * FTP_CloseFindNextHandle (internal)
2674 *
2675 * Deallocate session handle
2676 *
2677 * RETURNS
2678 * TRUE on success
2679 * FALSE on failure
2680 *
2681 */
2682 static void FTP_CloseFindNextHandle(LPWININETHANDLEHEADER hdr)
2683 {
2684 LPWININETFINDNEXTW lpwfn = (LPWININETFINDNEXTW) hdr;
2685 DWORD i;
2686
2687 TRACE("\n");
2688
2689 for (i = 0; i < lpwfn->size; i++)
2690 {
2691 HeapFree(GetProcessHeap(), 0, lpwfn->lpafp[i].lpszName);
2692 }
2693
2694 HeapFree(GetProcessHeap(), 0, lpwfn->lpafp);
2695 HeapFree(GetProcessHeap(), 0, lpwfn);
2696 }
2697
2698 /***********************************************************************
2699 * FTP_CloseFileTransferHandle (internal)
2700 *
2701 * Closes the file transfer handle. This also 'cleans' the data queue of
2702 * the 'transfer conplete' message (this is a bit of a hack though :-/ )
2703 *
2704 */
2705 static void FTP_CloseFileTransferHandle(LPWININETHANDLEHEADER hdr)
2706 {
2707 LPWININETFILE lpwh = (LPWININETFILE) hdr;
2708 LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) lpwh->hdr.lpwhparent;
2709 INT nResCode;
2710
2711 TRACE("\n");
2712
2713 if (!lpwh->session_deleted)
2714 lpwfs->download_in_progress = NULL;
2715
2716 /* This just serves to flush the control socket of any spurrious lines written
2717 to it (like '226 Transfer complete.').
2718
2719 Wonder what to do if the server sends us an error code though...
2720 */
2721 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2722
2723 if (lpwh->nDataSocket != -1)
2724 closesocket(lpwh->nDataSocket);
2725
2726 HeapFree(GetProcessHeap(), 0, lpwh);
2727 }
2728
2729 /***********************************************************************
2730 * FTP_ReceiveFileList (internal)
2731 *
2732 * Read file list from server
2733 *
2734 * RETURNS
2735 * Handle to file list on success
2736 * NULL on failure
2737 *
2738 */
2739 static HINTERNET FTP_ReceiveFileList(LPWININETFTPSESSIONW lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
2740 LPWIN32_FIND_DATAW lpFindFileData, DWORD dwContext)
2741 {
2742 DWORD dwSize = 0;
2743 LPFILEPROPERTIESW lpafp = NULL;
2744 LPWININETFINDNEXTW lpwfn = NULL;
2745 HINTERNET handle = 0;
2746
2747 TRACE("(%p,%d,%s,%p,%ld)\n", lpwfs, nSocket, debugstr_w(lpszSearchFile), lpFindFileData, dwContext);
2748
2749 if (FTP_ParseDirectory(lpwfs, nSocket, lpszSearchFile, &lpafp, &dwSize))
2750 {
2751 if(lpFindFileData)
2752 FTP_ConvertFileProp(lpafp, lpFindFileData);
2753
2754 lpwfn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETFINDNEXTW));
2755 if (lpwfn)
2756 {
2757 lpwfn->hdr.htype = WH_HFINDNEXT;
2758 lpwfn->hdr.lpwhparent = WININET_AddRef( &lpwfs->hdr );
2759 lpwfn->hdr.dwContext = dwContext;
2760 lpwfn->hdr.dwRefCount = 1;
2761 lpwfn->hdr.destroy = FTP_CloseFindNextHandle;
2762 lpwfn->hdr.lpfnStatusCB = lpwfs->hdr.lpfnStatusCB;
2763 lpwfn->index = 1; /* Next index is 1 since we return index 0 */
2764 lpwfn->size = dwSize;
2765 lpwfn->lpafp = lpafp;
2766
2767 handle = WININET_AllocHandle( &lpwfn->hdr );
2768 }
2769 }
2770
2771 if( lpwfn )
2772 WININET_Release( &lpwfn->hdr );
2773
2774 TRACE("Matched %ld files\n", dwSize);
2775 return handle;
2776 }
2777
2778
2779 /***********************************************************************
2780 * FTP_ConvertFileProp (internal)
2781 *
2782 * Converts FILEPROPERTIESW struct to WIN32_FIND_DATAA
2783 *
2784 * RETURNS
2785 * TRUE on success
2786 * FALSE on failure
2787 *
2788 */
2789 BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData)
2790 {
2791 BOOL bSuccess = FALSE;
2792
2793 ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAW));
2794
2795 if (lpafp)
2796 {
2797 /* Convert 'Unix' time to Windows time */
2798 RtlSecondsSince1970ToTime(mktime(&lpafp->tmLastModified),
2799 (LARGE_INTEGER *) &(lpFindFileData->ftLastAccessTime));
2800 lpFindFileData->ftLastWriteTime = lpFindFileData->ftLastAccessTime;
2801 lpFindFileData->ftCreationTime = lpFindFileData->ftLastAccessTime;
2802
2803 /* Not all fields are filled in */
2804 lpFindFileData->nFileSizeHigh = 0; /* We do not handle files bigger than 0xFFFFFFFF bytes yet :-) */
2805 lpFindFileData->nFileSizeLow = lpafp->nSize;
2806
2807 if (lpafp->bIsDirectory)
2808 lpFindFileData->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
2809
2810 if (lpafp->lpszName)
2811 lstrcpynW(lpFindFileData->cFileName, lpafp->lpszName, MAX_PATH);
2812
2813 bSuccess = TRUE;
2814 }
2815
2816 return bSuccess;
2817 }
2818
2819 /***********************************************************************
2820 * FTP_ParseNextFile (internal)
2821 *
2822 * Parse the next line in file listing
2823 *
2824 * RETURNS
2825 * TRUE on success
2826 * FALSE on failure
2827 */
2828 static BOOL FTP_ParseNextFile(INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW lpfp)
2829 {
2830 static const char szSpace[] = " \t";
2831 DWORD nBufLen;
2832 char *pszLine;
2833 char *pszToken;
2834 char *pszTmp;
2835 BOOL found = FALSE;
2836 int i;
2837
2838 lpfp->lpszName = NULL;
2839 do {
2840 if(!(pszLine = INTERNET_GetNextLine(nSocket, &nBufLen)))
2841 return FALSE;
2842
2843 pszToken = strtok(pszLine, szSpace);
2844 /* ls format
2845 * <Permissions> <NoLinks> <owner> <group> <size> <date> <time or year> <filename>
2846 *
2847 * For instance:
2848 * drwx--s--- 2 pcarrier ens 512 Sep 28 1995 pcarrier
2849 */
2850 if(!isdigit(pszToken[0]) && 10 == strlen(pszToken)) {
2851 if(!FTP_ParsePermission(pszToken, lpfp))
2852 lpfp->bIsDirectory = FALSE;
2853 for(i=0; i<=3; i++) {
2854 if(!(pszToken = strtok(NULL, szSpace)))
2855 break;
2856 }
2857 if(!pszToken) continue;
2858 if(lpfp->bIsDirectory) {
2859 TRACE("Is directory\n");
2860 lpfp->nSize = 0;
2861 }
2862 else {
2863 TRACE("Size: %s\n", pszToken);
2864 lpfp->nSize = atol(pszToken);
2865 }
2866
2867 lpfp->tmLastModified.tm_sec = 0;
2868 lpfp->tmLastModified.tm_min = 0;
2869 lpfp->tmLastModified.tm_hour = 0;
2870 lpfp->tmLastModified.tm_mday = 0;
2871 lpfp->tmLastModified.tm_mon = 0;
2872 lpfp->tmLastModified.tm_year = 0;
2873
2874 /* Determine month */
2875 pszToken = strtok(NULL, szSpace);
2876 if(!pszToken) continue;
2877 if(strlen(pszToken) >= 3) {
2878 pszToken[3] = 0;
2879 if((pszTmp = StrStrIA(szMonths, pszToken)))
2880 lpfp->tmLastModified.tm_mon = ((pszTmp - szMonths) / 3)+1;
2881 }
2882 /* Determine day */
2883 pszToken = strtok(NULL, szSpace);
2884 if(!pszToken) continue;
2885 lpfp->tmLastModified.tm_mday = atoi(pszToken);
2886 /* Determine time or year */
2887 pszToken = strtok(NULL, szSpace);
2888 if(!pszToken) continue;
2889 if((pszTmp = strchr(pszToken, ':'))) {
2890 struct tm* apTM;
2891 time_t aTime;
2892 *pszTmp = 0;
2893 pszTmp++;
2894 lpfp->tmLastModified.tm_min = atoi(pszTmp);
2895 lpfp->tmLastModified.tm_hour = atoi(pszToken);
2896 time(&aTime);
2897 apTM = localtime(&aTime);
2898 lpfp->tmLastModified.tm_year = apTM->tm_year;
2899 }
2900 else {
2901 lpfp->tmLastModified.tm_year = atoi(pszToken) - 1900;
2902 lpfp->tmLastModified.tm_hour = 12;
2903 }
2904 TRACE("Mod time: %02d:%02d:%02d %02d/%02d/%02d\n",
2905 lpfp->tmLastModified.tm_hour, lpfp->tmLastModified.tm_min, lpfp->tmLastModified.tm_sec,
2906 (lpfp->tmLastModified.tm_year >= 100) ? lpfp->tmLastModified.tm_year - 100 : lpfp->tmLastModified.tm_year,
2907 lpfp->tmLastModified.tm_mon, lpfp->tmLastModified.tm_mday);
2908
2909 pszToken = strtok(NULL, szSpace);
2910 if(!pszToken) continue;
2911 lpfp->lpszName = WININET_strdup_AtoW(pszToken);
2912 TRACE("File: %s\n", debugstr_w(lpfp->lpszName));
2913 }
2914 /* NT way of parsing ... :
2915
2916 07-13-03 08:55PM <DIR> sakpatch
2917 05-09-03 06:02PM 12656686 2003-04-21bgm_cmd_e.rgz
2918 */
2919 else if(isdigit(pszToken[0]) && 8 == strlen(pszToken)) {
2920 lpfp->permissions = 0xFFFF; /* No idea, put full permission :-) */
2921
2922 sscanf(pszToken, "%d-%d-%d",
2923 &lpfp->tmLastModified.tm_mon,
2924 &lpfp->tmLastModified.tm_mday,
2925 &lpfp->tmLastModified.tm_year);
2926
2927 /* Hacky and bad Y2K protection :-) */
2928 if (lpfp->tmLastModified.tm_year < 70)
2929 lpfp->tmLastModified.tm_year += 100;
2930
2931 pszToken = strtok(NULL, szSpace);
2932 if(!pszToken) continue;
2933 sscanf(pszToken, "%d:%d",
2934 &lpfp->tmLastModified.tm_hour,
2935 &lpfp->tmLastModified.tm_min);
2936 if((pszToken[5] == 'P') && (pszToken[6] == 'M')) {
2937 lpfp->tmLastModified.tm_hour += 12;
2938 }
2939 lpfp->tmLastModified.tm_sec = 0;
2940
2941 TRACE("Mod time: %02d:%02d:%02d %02d/%02d/%02d\n",
2942 lpfp->tmLastModified.tm_hour, lpfp->tmLastModified.tm_min, lpfp->tmLastModified.tm_sec,
2943 (lpfp->tmLastModified.tm_year >= 100) ? lpfp->tmLastModified.tm_year - 100 : lpfp->tmLastModified.tm_year,
2944 lpfp->tmLastModified.tm_mon, lpfp->tmLastModified.tm_mday);
2945
2946 pszToken = strtok(NULL, szSpace);
2947 if(!pszToken) continue;
2948 if(!strcasecmp(pszToken, "<DIR>")) {
2949 lpfp->bIsDirectory = TRUE;
2950 lpfp->nSize = 0;
2951 TRACE("Is directory\n");
2952 }
2953 else {
2954 lpfp->bIsDirectory = FALSE;
2955 lpfp->nSize = atol(pszToken);
2956 TRACE("Size: %ld\n", lpfp->nSize);
2957 }
2958
2959 pszToken = strtok(NULL, szSpace);
2960 if(!pszToken) continue;
2961 lpfp->lpszName = WININET_strdup_AtoW(pszToken);
2962 TRACE("Name: %s\n", debugstr_w(lpfp->lpszName));
2963 }
2964 /* EPLF format - http://cr.yp.to/ftp/list/eplf.html */
2965 else if(pszToken[0] == '+') {
2966 FIXME("EPLF Format not implemented\n");
2967 }
2968
2969 if(lpfp->lpszName) {
2970 if((lpszSearchFile == NULL) ||
2971 (PathMatchSpecW(lpfp->lpszName, lpszSearchFile))) {
2972 found = TRUE;
2973 TRACE("Matched: %s\n", debugstr_w(lpfp->lpszName));
2974 }
2975 else {
2976 HeapFree(GetProcessHeap(), 0, lpfp->lpszName);
2977 lpfp->lpszName = NULL;
2978 }
2979 }
2980 } while(!found);
2981 return TRUE;
2982 }
2983
2984 /***********************************************************************
2985 * FTP_ParseDirectory (internal)
2986 *
2987 * Parse string of directory information
2988 *
2989 * RETURNS
2990 * TRUE on success
2991 * FALSE on failure
2992 */
2993 static BOOL FTP_ParseDirectory(LPWININETFTPSESSIONW lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
2994 LPFILEPROPERTIESW *lpafp, LPDWORD dwfp)
2995 {
2996 BOOL bSuccess = TRUE;
2997 INT sizeFilePropArray = 500;/*20; */
2998 INT indexFilePropArray = -1;
2999
3000 TRACE("\n");
3001
3002 /* Allocate intial file properties array */
3003 *lpafp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FILEPROPERTIESW)*(sizeFilePropArray));
3004 if (!*lpafp)
3005 return FALSE;
3006
3007 do {
3008 if (indexFilePropArray+1 >= sizeFilePropArray)
3009 {
3010 LPFILEPROPERTIESW tmpafp;
3011
3012 sizeFilePropArray *= 2;
3013 tmpafp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *lpafp,
3014 sizeof(FILEPROPERTIESW)*sizeFilePropArray);
3015 if (NULL == tmpafp)
3016 {
3017 bSuccess = FALSE;
3018 break;
3019 }
3020
3021 *lpafp = tmpafp;
3022 }
3023 indexFilePropArray++;
3024 } while (FTP_ParseNextFile(nSocket, lpszSearchFile, &(*lpafp)[indexFilePropArray]));
3025
3026 if (bSuccess && indexFilePropArray)
3027 {
3028 if (indexFilePropArray < sizeFilePropArray - 1)
3029 {
3030 LPFILEPROPERTIESW tmpafp;
3031
3032 tmpafp = HeapReAlloc(GetProcessHeap(), 0, *lpafp,
3033 sizeof(FILEPROPERTIESW)*indexFilePropArray);
3034 if (NULL == tmpafp)
3035 *lpafp = tmpafp;
3036 }
3037 *dwfp = indexFilePropArray;
3038 }
3039 else
3040 {
3041 HeapFree(GetProcessHeap(), 0, *lpafp);
3042 INTERNET_SetLastError(ERROR_NO_MORE_FILES);
3043 bSuccess = FALSE;
3044 }
3045
3046 return bSuccess;
3047 }
3048
3049
3050 /***********************************************************************
3051 * FTP_ParsePermission (internal)
3052 *
3053 * Parse permission string of directory information
3054 *
3055 * RETURNS
3056 * TRUE on success
3057 * FALSE on failure
3058 *
3059 */
3060 static BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp)
3061 {
3062 BOOL bSuccess = TRUE;
3063 unsigned short nPermission = 0;
3064 INT nPos = 1;
3065 INT nLast = 9;
3066
3067 TRACE("\n");
3068 if ((*lpszPermission != 'd') && (*lpszPermission != '-') && (*lpszPermission != 'l'))
3069 {
3070 bSuccess = FALSE;
3071 return bSuccess;
3072 }
3073
3074 lpfp->bIsDirectory = (*lpszPermission == 'd');
3075 do
3076 {
3077 switch (nPos)
3078 {
3079 case 1:
3080 nPermission |= (*(lpszPermission+1) == 'r' ? 1 : 0) << 8;
3081 break;
3082 case 2:
3083 nPermission |= (*(lpszPermission+2) == 'w' ? 1 : 0) << 7;
3084 break;
3085 case 3:
3086 nPermission |= (*(lpszPermission+3) == 'x' ? 1 : 0) << 6;
3087 break;
3088 case 4:
3089 nPermission |= (*(lpszPermission+4) == 'r' ? 1 : 0) << 5;
3090 break;
3091 case 5:
3092 nPermission |= (*(lpszPermission+5) == 'w' ? 1 : 0) << 4;
3093 break;
3094 case 6:
3095 nPermission |= (*(lpszPermission+6) == 'x' ? 1 : 0) << 3;
3096 break;
3097 case 7:
3098 nPermission |= (*(lpszPermission+7) == 'r' ? 1 : 0) << 2;
3099 break;
3100 case 8:
3101 nPermission |= (*(lpszPermission+8) == 'w' ? 1 : 0) << 1;
3102 break;
3103 case 9:
3104 nPermission |= (*(lpszPermission+9) == 'x' ? 1 : 0);
3105 break;
3106 }
3107 nPos++;
3108 }while (nPos <= nLast);
3109
3110 lpfp->permissions = nPermission;
3111 return bSuccess;
3112 }
3113
3114
3115 /***********************************************************************
3116 * FTP_SetResponseError (internal)
3117 *
3118 * Set the appropriate error code for a given response from the server
3119 *
3120 * RETURNS
3121 *
3122 */
3123 static DWORD FTP_SetResponseError(DWORD dwResponse)
3124 {
3125 DWORD dwCode = 0;
3126
3127 switch(dwResponse)
3128 {
3129 case 421: /* Service not available - Server may be shutting down. */
3130 dwCode = ERROR_INTERNET_TIMEOUT;
3131 break;
3132
3133 case 425: /* Cannot open data connection. */
3134 dwCode = ERROR_INTERNET_CANNOT_CONNECT;
3135 break;
3136
3137 case 426: /* Connection closed, transer aborted. */
3138 dwCode = ERROR_INTERNET_CONNECTION_ABORTED;
3139 break;
3140
3141 case 500: /* Syntax error. Command unrecognized. */
3142 case 501: /* Syntax error. Error in parameters or arguments. */
3143 dwCode = ERROR_INTERNET_INCORRECT_FORMAT;
3144 break;
3145
3146 case 530: /* Not logged in. Login incorrect. */
3147 dwCode = ERROR_INTERNET_LOGIN_FAILURE;
3148 break;
3149
3150 case 550: /* File action not taken. File not found or no access. */
3151 dwCode = ERROR_INTERNET_ITEM_NOT_FOUND;
3152 break;
3153
3154 case 450: /* File action not taken. File may be busy. */
3155 case 451: /* Action aborted. Server error. */
3156 case 452: /* Action not taken. Insufficient storage space on server. */
3157 case 502: /* Command not implemented. */
3158 case 503: /* Bad sequence of command. */
3159 case 504: /* Command not implemented for that parameter. */
3160 case 532: /* Need account for storing files */
3161 case 551: /* Requested action aborted. Page type unknown */
3162 case 552: /* Action aborted. Exceeded storage allocation */
3163 case 553: /* Action not taken. File name not allowed. */
3164
3165 default:
3166 dwCode = ERROR_INTERNET_INTERNAL_ERROR;
3167 break;
3168 }
3169
3170 INTERNET_SetLastError(dwCode);
3171 return dwCode;
3172 }
Windows API implementation