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