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