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